#include <stdio.h>
#include <stdlib.h>
#define fila 3
#define col 2
#define max 3
typedef struct infoAlum{
	char nombre[15];
	int matricula;
	float cal[2];
	float prom;
}alumnos;
 
int main(){
	alumnos **alum;
	int i,j,k;
	float prom;
	alum = (alumnos**)malloc(fila*sizeof(alumnos*));
 
//	For para columnas
	for(i=0;i<fila;i++){
		alum[i]=(alumnos*)malloc(col*sizeof(alumnos));
	}
 
	printf("Introduzca los valores de la matriz\n");
 
	for(i=0;i<fila;i++){
		for(j=0;j<col;j++){
			printf("Introduce el nombre del alumno numero [%d] [%d]\n",i+1,j+1);
			scanf("%s", alum[i][j].nombre);
			printf("Introduce la matricula del alumno numero [%d] [%d]\n",i+1,j+1);
			scanf("%d",&alum[i][j].matricula);
					for(k=0;k<max;k++){
						printf("Introduce la calificacion %d del alumno numero [%d] [%d]\n",k+1,i+1,j+1);
						scanf("%f",&alum[i][j].cal[k]);
						printf("%f\n",alum[i][j].cal[k]);
						alum[i][j].prom=(alum[i][j].cal[k]+alum[i][j].prom);
						printf("La suma en turno %d es %f\n",k+1, alum[i][j].prom);
					}
			alum[i][j].prom =(alum[i][j].prom)/3;
				printf("El promedio de %s es %f \n",alum[i][j].nombre, alum[i][j].prom);
		}
	}
	for(i=0;i<fila;i++){
		for(j=0;j<col;j++){
			printf("Nombre: [%s] \t",alum[i][j].nombre);
			printf("Matricula: [%d] \t",alum[i][j].matricula);
			printf("Promedio [%.2f] \n",alum[i][j].prom);
		}
	}
 
 
//	Liberando los apuntadores de memoria
	for (i=0;i<fila;i++){
		for(j=0;j<col;j++){
			free(alum[i]);
			free(alum);
		}
	}
} 

---

MOD: El código debe ir entre etiquetas de Código GeSHi

Estás intentando guardar 3 (max) notas en un array de longitud 2 (cal)... 
Además si estás usando un 'define' para guardar [max = 3], luego úsalo para calcular el promedio en lugar de dividir directamente entre 3.

Y por otro lado, no estás liberando bien la matriz dinámica.
Fíjate en cómo reservas la memoria pues para liberarla el proceso es el mismo. Lo que reservas con bucle, lo liberas con bucle y lo que reservas una vez, lo liberas una vez:

for(int i = 0; i < filas; i++) {
    free(alumnos[i]);
}
free(alumnos); 

El uso de la flecha tal que:

variable->campo

Es equivalente a hacer:

(*variable).campo

La flecha simplemente permite simplificar un poco las expresiones para que no quede tan engorroso.
En este caso concreto, al ser una matriz, cuando haces:
Ya estás accediendo a un elemento de tipo <alumnos> no a un puntero, por eso tienes que usar el punto.

Si usases aritmética de punteros para acceder a la matriz (si no me he equivocado, ambas líneas muestran exactamente lo mismo):

printf("%s\n", matriz[i][j].nombre);
printf("%s\n", (*(*(matriz + i) + j)).nombre); // Usando aritmetica de punteros 

Podrías simplificar la segunda expresión haciendo uso de la flecha:

printf("%s\n", (*(matriz + i) + j)->nombre); 

Pero como puedes ver, con matrices siempre es más sencillo utilizar los índices.

---

Ya puestos, otro extra:
Al momento de crear el struct, si utilizas typedef, no es necesario que asignes un primer nombre, bastaría con el del final.
Poner un nombre al principio y otro al final sólo es necesario si quieres hacer referencia a la propia struct dentro de sí misma.

typedef struct {
  //...
  //...
} InfoAlumno; 

Y el nombre mejor en singular, has creado una estructura, no un array de esa estructura. Luego ya si creas un array, llamas a la variable en plural:

InfoAlumno **alumnos; 

Por qué? No entiendo a qué te refieres