Has iniciado factorial a 1, si fuera 0, cualquier multiplicación posterior daría 0.
Si i=1, la primera iteración (te guste o no) es esa, i=1.
Otra cosa es que resulte superfluo multiplicar factorial por 1.Pues 1x1 = 1.
Ergo, puedes inicializar el bucle con i=2 (siempre que 'numero' fuere mayor que 1).


...de hecho tu código fallará si se introduce para numero un valor menor que 1.

Siendo sinónimos ejecución de un bucle e iteración de un bucle está claro que no es lo mismo que repetición.

Ejemplo trivial.

#include <stdio.h>
 
int main() {
	int ejecuciones = 1;
	int repeticiones = 0;
 
	while(ejecuciones <= 5) {
		printf("Esta es la %da iteración de este bucle, repetición %d\n", ejecuciones, repeticiones);
		ejecuciones++;
		repeticiones++;
	}
}

Este tema tenía que llamarse: "Hacer complicado lo simple" 

Empezamos por decir que una iteración es cada una de las repeticiones de un proceso.
Partiendo de eso, cuántas iteraciones tiene calcular el factorial de 5 o cualquier otro proceso? Pues las que tu algoritmo defina. Un mismo problema se puede solucionar con diferentes algoritmos que varíen el número de iteraciones para resolverlo.

Creo que se explica más fácil con código:

for(int i = 0; i < 0; ++i); // Este bucle no se va a ejecutar nunca. Iteraciones = 0
for(int i = 0; i < 1; ++i); // Este bucle se va a ejecutar 1 vez: i = {0}. Iteraciones = 1
for(int i = 0; i < num; ++i); // Este bucle se va a ejecutar num-veces si num >= 0 y 0-veces si num < 0. Iteraciones = MAX(0, num)
 
// Y si i no empieza en 0, todo funciona igual
for(int i = 10; i < 15; ++i); // Este bucle se va a ejecutar 5 veces: i = {10, 11, 12, 13, 14}. Iteraciones = 5
 
// De forma general:
for(int i = a; i < b1; ++i); // Este bucle se va a repetir (b1-a) veces o 0 si el resultado es negativo (como antes). Iteraciones = MAX(0, (b1-a)) 
// Y teniendo en cuenta que el anterior bucle es igual a:
for(int i = a; i <= b1-1; ++i); // Iteraciones: MAX(0, (b1-a)) = MAX(0, (b1-1-a+1))
 
// Consideramos que b2 = b1-1 y juntamos conclusiones:
for(int i = a; i <= b2; ++i); // Iteraciones: MAX(0, (b2-a+1)) 

Y ahí tenemos cómo calcular el número de iteraciones de un bucle de forma general tanto cuando el comparador es '<' o '<='.

Ahora vamos al código original:
Cuántas iteraciones realiza? MAX(0, (numero-1+1)) = MAX(0, numero)
Es decir: numero-iteraciones si numero >= 0 o 0 en caso contrario -> numero = 5 -> El programa realiza 5 iteraciones, no hay más.

Que la primera iteración no tiene sentido porque el 1 es el elemento neutro de la multiplicación y entonces multiplicar por 1 es como no hacer nada? Efectivamente, pero ese programa realiza 5 iteraciones.
Si consideras que la primera no es necesaria y realizas la siguiente modificación:

for(int i = 2; i <= numero; ++i) {
  factorial *= i; // Forma corta de escribir: factorial = factorial * i
} 

Ahora, cuántas iteraciones realiza este bucle? MAX(0, (numero-2+1)) = MAX(0, (numero-1)) -> numero = 5 -> MAX(0, (5-1)) = MAX(0, 4) = 4 iteraciones

Todo depende de cómo se implemente el algoritmo no de "yo considero que esta no cuenta". Si consideras que algo no cuenta pero tu programa lo está haciendo, entonces cuenta. Si no quieres que cuente, haz que tu programa no lo haga y entonces no contará.