En general el código está bien. Las funciones no sobrepasan un Xterm (23 líneas).

¿Qué cosas modificaría? Pues generalizar ese problema para mostrar los factoriales de 0 a N con una constante:

/* Se despliegan los factoriales de los numeros del 0 al N, se utiliza la recursividad para calcularlos */
#include <stdio.h>
 
#define N 15
 
 /* Prototipo de funcion */
long calculaFactorial( long numero );
void muestraLlamadasRecursivas( long numero );
 
/* Inicia la ejecucion del programa */
int main()
{
 
	int i; /* Contador */
 
	printf( "\n\n***Este programa imprime los factoriales de los numeros del 0 al %d\n", N );
	printf( "y sus llamadas recursivas a la funcion que calcula los mismos.\n" );
	printf( "Este programa se crea con la finalidad de hacer que sea mas facil\n" );
	printf( "entender el tema de recursividad***\n\n" );
 
	/* Repite N+1 veces; durante cada iteracion calcula el factorial de i y lo despliega en pantalla */
	for ( i = 0; i <= N; i++ )
	{
		printf( "%d! = %ld\n", i, calculaFactorial( i ) ); /* Imprimimos el valor del factorial */
		muestraLlamadasRecursivas( i ); /* Llamamos a la funcion que imprime las llamadas a funcion */
	}
 
	return 0; /* Terminacion exitosa */
 
} /* Fin de main */
 
/* Definicion recursiva de la funcion factorial */
long calculaFactorial( long numero )
{
	/* Caso base */
	if ( numero <= 1 ) {
		return 1;
	} /* Fin de if */
	else {	/* Paso recursivo o llamada recursiva */
		return ( numero * calculaFactorial( numero - 1 ) );
	} /* Fin de else */
} /* Fin de la funcion factorial */
 
void muestraLlamadasRecursivas( long numero )
{
	static int contadorEspacios = 1;	/* es static para que el valor no se destruya entre las llamadas recursivas a funcion */
	int contador = contadorEspacios; /* Variable que determinara el numero de espacios a imprimir */
 
	for ( contador; contador >= 1; contador-- ) { /* Imprimimos los espacios correspondientes */
			printf( " " );
	} /* Fin de for */
 
	if ( numero <= 1 ) {
		printf( "1\n" );
		printf( "-------------------\n" );
	}
	else {
		printf( "%ld * factorial( %ld - 1 )\n", numero, numero );		/* Imprimimos la llamada recursiva */
		contadorEspacios++;	/* Agregamos 1 a la variable de espacios */
		muestraLlamadasRecursivas( numero - 1 );		/* Llamamos recursivamente a la funcion */
	}
 
	contadorEspacios = 1; /* Reestablecemos la variable a 1 para que no se vallan a imprimir los espacios ya calculados en el factorial anterior*/
} /* Fin de funcion muestraLlamadasRecursivas */
 
 

En este caso no es recomendable usar recursividad porque derrochamos demasiada memoria con cada cambio de contexto, aunque está bien de forma didáctica (para comprender la recursividad y porque generalmente el código es mucho más inteligible).

Y si preguntas por reestructurar... dividiría el main en dos funciones: 1 para el título y otra para el proceso principal, aunque no es imprescindible.

Por último, tus comentarios están bien pero son excesivos. Para alguien al que le vas a explicar algo nuevo están bien pero pero hay que mantenerlos escuetos y tratar de no poner comentarios innecesarios.

En conclusión, es un código interesante para comprender como funciona la recursividad pero inviable en un código optimizado.

¡Enhorabuena!