El sistema numérico de un ordenador no es sexagesimal por lo que no se pondrá a 0 cuándo llegue la cuenta a 60. Tampoco sabe que 60 segundos son un minuto. Todo eso tendrás que enseñárselo.

Por cierto: no puedes Horas no pueden ser 24, ni los minutos ni los segundos pueden ser 60.

La premisa para que funcione la función es que la lista siempre debe estar terminada con NULL. Si está vacía debe estar apuntando a NULL.

La función pondrá el nodo generado con el dato al final de la lista. Siguiendo la primera premisa éste último nodo debe apuntar a NULL en next.

Lo que se hace es:
Se genera un nodo a partir de la información dada por data.

Si la lista está vacía, NULL, pasará a apuntar al nodo nuevo.
Si la lista no está vacía hay que recorrerla hasta encontrar el último elemento (aquel que apunte a NULL), cambiar el valor next para que apunte al nuevo nodo generado y regresar la lista entera, eso es el primer elemento (list).

Lo que ves en

while (slist_next(node) != slist_nil()) {
    node = slist_next(node);

es precisamente ese recorrido. node apunta al principio de la lista (list) y vamos a trabajar sobre node. Mientras el elemento next de node no sea NULL, node apuntará a node->next (en el código esto está encapsulado por node = slist_next(node). Una vez llegado a éste último elemento la orden list_next(node) = newNode; coloca el nuevo nodo al final de la lista.
Como el inicio de la lista no ha sido modificado (list) y hay que regresar un puntero, precisamente al inicio de la lista, devolvemos list.

Otra versión sin estas macros es así:

SList slist_append(SList list, int data) {
    Slist node;
    SList newNode = malloc(sizeof(SNode));
 
    newNode->data = data;
    newNode->next = NULL;
 
    if(list == NULL)
        return newNode;
 
    node = list;
 
    while(node->next != NULL)
        node = node->next;
 
    node->next = newNode;
 
    return list;
}

Eso es strncmp 

strcmp busca una correspondencia 1 a 1 entre las dos cadenas por tanto

• ¿Hay diferencias de capitalización entre las dos cadenas?
• ¿Usas una família gets por un lado y scanf por otro? (las famílias fgets guardan el '\n', scanf no lo guarda)
• Cuándo guardas los nicks en main, o donde sea, ¿estás seguro que no quedan carácteres en el buffer de entrada y se los pasas a la siguiente cadena cuándo vuelves a pedir datos?

Bien, veo que lo has escrito deprisa y corriendo. Para otra vez formatea el código, se agradece verlo bien presentado.

Dentro del bucle do-while, pon la primera instrucción que lleve control a 0. Si hay algún fallo control empezará el bucle ya con código de error y no saldrás de él.

Para scanf, debes hacer que acepte un máximo de 4 caracteres, sino podrías crear desbordamiento de la variable resp. Sobre la variable resp, ella misma ya actúa como puntero y no debes pasarle la dirección de memoria.

No uses fflush(stdin) no es estándar y no va bien con todos los compiladores. Hay alternativas con funciones de librería y un poco de código.

resp<'0'&& resp>'9' puedes sustituirlo por la función de librería isdigit de ctype.h

En el 'case 0' has escrito, en su última instrucción control==1, una comparación sin efecto. Supongo que querías hacer una asignación.

La funciones lo que hacen es devolver el inicio de la lista modificada.
Le entregas la lista y la modificación y la función te la devuelve modificada.

Si quieres que sea más específico deberás decirme exactamente que es que no entiendes.

Está bien lo de la optimización, pero te has saltado lo de que el usuario entra la coordenada de donde quiere el 0. Si lo pone en una esquina no puede haber espejos y el máximo valor del recuadro es 10.

Si a una mitad del recuadro la tratas de una forma y a la otra mitad la tratas de otra nunca llegarás a una solución coherente.
En vez de usar un cuadro de 11x11 usa uno de 3x3 y sitúate en el centro. Obviamente el anillo exterior todo son 1s.
Reduciendo más el problema, si tomas en cuenta solo la distancia de los puntos en el eje X
y teniendo en cuenta solo la distancia de los puntos en el eje Y
Superponiendo estos dos últimos recuadros y tomando la conjunción lógica de ambos queda
¿Qué operación hace que los 0 del anillo tomen el valor de las esquinas?

Hace una cosa extraña.

Está pensado para modificar la misma lista que se le pasa, pero en vez de modificar directamente el parámetro list lo que hace es modificarlo y regresar un puntero con el dato modificado. Seguramente el autor pensó en esa solución para dar un valor en caso de que list fuera NULL. Pero hubiera hecho lo mismo con un puntero a puntero y el resultado habría sido más natural.

Supongamos el siguiente trozo de código:

SList mi_lista = NULL;
 
mi_lista = slist_append(mi_lista, 5);

Ahora mi_lista pasa a tener un elemento con un valor en data de 5. Continuamos con la variable mi_lista tal y como la hemos dejado en el siguiente código:

mi_lista = slist_append(mi_lista, 7); 

Ahora mi_lista tiene dos elementos, uno que contiene el 5 y otro que contiene el 7. Se puede representar así [5 , 7].

Pero qué pasaría si hubiera:

SList lista_uno = NULL;
SList lista_dos = NULL;
 
lista_uno = slist_append(lista_uno, 5);
lista_dos = slist_append(lista_uno, 7);

¿Era esto lo que esperaba el autor que se hiciera?

Casi mejor hubiera sido definir la función con un puntero a puntero.

void slist_append(SList * list, int data) {
    /* Implementación de la función */
}
 
/* Código y más código */
 
SList mi_lista = NULL;
slist_append(&mi_lista, 5);
slist_append(&mi_lista, 7);

Ahora mi_lista estaría actualizada con [5 , 7] pero no habría posibilidad de darle a otra lista la posibilidad de acceder a los datos de ésta con lo que se previenen errores a la hora de escribir el programa.

Por otra parte esconder un puntero dentro de un typedef no es muy buena práctica, pero cada uno hace lo que quiere.

Por otra parte, sobre la primera pregunta: tal vez un array de punteros. Los elementos apuntados no se mueven de su sitio, lo que cambias son los punteros del array y tienes un array para acceder a ellos.

Sí, cada compilador genera su propio código y en verdad no se puede asegurar que uno u otro optimice más.
Por ejemplo GCC con O2 no genera ni el array en el ejemplo del array en pila de Eternal Idol:

main:
.LFB24:
	.cfi_startproc
	sub	rsp, 8
	.cfi_def_cfa_offset 16
	mov	edx, 2
	mov	esi, OFFSET FLAT:.LC0
	mov	edi, 1
	xor	eax, eax
	call	__printf_chk
	xor	eax, eax
	add	rsp, 8
	.cfi_def_cfa_offset 8
	ret
	.cfi_endproc

---

Todo depende de cada compilador y de la configuración que se le da. Continuar ahora sería entrar en una guerra de compiladores, jeje, y no es plan.