Hay una ventaja que tiene usar tipos y es que el compilador te ayuda a chequear que los datos que pasas calzan con los que esperas y al usar void* abres la puerta a una serie de problemas que se producen cuando no hay calce.

El hecho que la funcion te indique el tipo de parametro no es ninguna garantia que el tipo guardado sea el que esperas.

No tiene sentido que tu funcion retorne un void* si estas retornando un info *.
Cambia el tipo de retorno a info*

Si mantienes algo de memoria adicional, es posible saber si uno de los jugadores gano' sin hacer recorridos, ni ciclos.

Mientras se juega hay que actualizar esa memoria adicional, lo que tampoco requiere hacer recorridos ni ciclos.

La idea es asignar 2 valores opuestos a cada jugador, por ejemplo 1 y -1. Si un jugador ha ganado, la suma de esa fila, columna o diagonal sera 3 (o -3). Cualquier valor distinto a eso, no hay ganador.

Para poder asignarle a esos campos, necesitas direcciones de memoria, no valores.
En C++ podrias hacer:

nuevo->cad1 = new int(aux1);

En C, tienes que pedir memoria con malloc, asignar a esa memoria, luego asignarle a cad1 la memoria.

    int *pint = (int*) malloc(sizeof(int));
    *pint = aux1;
    nuevo->cad1 = pint;
 

Me pregunto como haras para saber de que tipo son los valores que asignaste para luego recuperar su valor?

Tal vez conviene saber que quieres hacer con estos campos de tipo desconocido porque posiblemente se puede resolver sin tener que hacer esto.

Opcion a lo mencionado previamente: Usar lambdas para implementar el comparator

import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
import java.util.Comparator;
 
public class Persona {
     String nombre;
     int edad;
 
     public Persona(String nombre, int edad) {
         this.nombre = nombre;
         this.edad = edad;
     }
 
     public static void ordenaLista(List<Persona> l, String titulo, 
                                    Comparator<Persona> comp) {
         Collections.sort(l, comp);
         System.out.println(titulo);
         for(Persona p: l) {
             System.out.println(p.nombre + " " + p.edad);
         }
     }
 
     public static void main(String []args){
         ArrayList<Persona> l = new ArrayList<>();
         l.add(new Persona("A", 30));
         l.add(new Persona("B", 29));
         l.add(new Persona("C", 28));
         l.add(new Persona("D", 27));
 
         ordenaLista(l, "Por nombre", (p1, p2) -> p1.nombre.compareTo(p2.nombre));
         ordenaLista(l, "Por edad", (p1, p2) -> (p1.edad - p2.edad));
     }
}
 

El operador ^ no es para potencias.

Dudas:

Por que dices que no te sirve lo que comente antes?
Has resuelto el problema de la incompatibilidad de tipos de otra forma?
Ahora preguntas otra cosa?

Has definido nombre como un arreglo de strings. pero le asignas al arreglo solo 1 string. No puedes hacer esto.

Tienes que asignar ese string, solo a 1 de las posiciones del arreglo
al estilo

nombre[4] = "hola";

suponiendo que quieres modificar el string con indice 4 dentro del arreglo nombre

sugiero que recibas lo que va_arg te retorna en una variable del tipo que pides.

Ejemplo en linea 28 y siguientes:

cambia por

  int miVariableInt;  // al inicio de la funcion
 
 // y luego en el switch, para el caso .'i'
  miVariableInt = va_arg(args, int);
  itoa(miVariableInt, buffer, 10);
  print_string(buffer);

Y si esto se comporta bien, hacer los mismos con los otros tipos.

Muestra el codigo modificado

Tienes que variar el tipo del segundo parametro de va_arg.

Tu solo usas unsigned int (o int) y deberias usar el tipo que calce con el % que se pasa.

Mira el ejemplo al final de aqui: https://linux.die.net/man/3/va_arg