1. If you can include the appropriate header, do that. Redefining yourself is error-prone even where allowed. This is C not C++, headers are simple enough it doesn't significantly influence compile-time.

2. If you add the origin of a constant in a comment, try to instead let the compiler determine it from the true source for you.

    char result[9] = "";  // strlen("fizzbuzz") + 1 == 9
   

   becomes the simpler and shorter

    char result[sizeof "fizzbuzz"] = "";
   

3. If you can, avoid copying strings around. Your pattern has period 3*5==15, so use an array. You can even compress it if you want, though that is overkill.

4. return 0; is implicit for main() since C99. While return EXIT_SUCCESS; might be a different successful execution, afaik there is no implementation which differentiates.

This is what it looks like when you pander to the little tin god, without completely loosing your head:

#include <stdio.h>

void fizzbuzz(unsigned n) {
#define Z "\n\0"
#define F "fizz"
#define X "%u" Z
    const char* text = X F Z F "buzz\n";
    static const char index[] = {
        sizeof(X F Z),   1,         1,         sizeof(X), 1,
        sizeof(X F Z F), sizeof(X), 1,         1,         sizeof(X),
        sizeof(X F Z F), 1,         sizeof(X), 1,         1,
    };
#undef X
#undef F
#undef Z
    printf(text + index[n % 15] - 1, n);
}

int main() {
    for (unsigned i = 1; i < 100; ++i)
        fizzbuzz(i);
}

Or after encoding data and offsets with a custom program (we are now far beyond overkill), it becomes this:

#include <stdio.h>

void fizzbuzz(unsigned n) {
    const char* p = "\31\17\17\23\17\35\23\17\17\23\35\17\23"
        "\17\17%u\n\0fizz\n\0fizzbuzz\n";
    printf(p + p[n % 15], n);
}

int main() {
    for (unsigned i = 1; i < 100; ++i)
        fizzbuzz(i);
}

The difficult part was converting the calculated string into a valid short source-code literal. Trickier than one might think.

Re-use

could include stdlib so as not to have to define EXIT_SUCCESS myself, but as I only needed this constant, it's a little clearer and more efficient to do this

Consider someone uses your good code as part of a larger task and does include <stdlib.h>, then the compiler may warn about the redefinition. Now the next coder needs to spend time sorting this out.

Tip: plan for code re-use and consider the next guy. Avoid re-implementing the standard library.

Buffer too small

char result[9] .... sprintf(result, "%d", n) --> result too small for all int. Be more generous.

Various ways to pre-calculate buffer needs.

 #define INT_STRING_N (sizeof(int)*CHAR_BIT/3 + 3)
 #define FIZZBUZZ_STRING_N 9
 #define BUFF_N (INT_STRING_N > FIZZBUZZ_STRING_N ? INT_STRING_N : FIZZBUZZ_STRING_N)

 char result[BUFF_N];

I favor using 2x buffers (twice the expected max needed size) and snprintf() for less controlled cases.