Las pautas que te dan te solucionan casi todo el problema.
Empieza por crear la estructura de los números complejos.

Empecemos por el principio.
cad es el array que guarda la cadena en bruto. Se puede considerar cad como un puntero al primer elemento de dicho array.
pos es un puntero que recorre todo el array en bruto. De él se toman los caracteres para decidir que hacer con ellos.
des es un puntero que va a ser usado para formar el array nuevo. Solo se actualiza su posición cuando se ha soltado un carácter válido.

Para empezar hacemos que pos y des apunten al principio de cad.

Una bandera, espacio_escrito, sirve para saber si hemos escrito un carácter espacio y para marcar que no se escriban más en caso de que hubieren varios seguidos en la cadena en bruto.

Tip: en C, y para operaciones lógicas, todo valor 0 es falso y todo valor diferente de 0 es cierto.

Sí !espacio_escrito es igual a espacio_escrito==0.

Dentro del if que mira si estamos ante un espacio en blanco (un espacio o una tabulación) debemos mirar que no estemos al principio de la cadena nueva: no nos interesa poner espacios al principio de ella. Y esto es lo que hace des != cad: mira las direcciones a las que apuntan los dos punteros. Si son iguales no debemos escribir ningún espacio y por lo tanto saltamos todo el código de ese if.
De igual forma, si ya no estamos al principio de esa cadena, debemos mirar si con anterioridad hemos escrito un espacio o no, y eso es lo que hacemos mediante la bandera espacio_escrito. Si no se ha escrito un espacio debemos escribir uno y eso es lo que hace el código, además activamos la bandera a 1; así en los posteriores caracteres, si son blancos ya no escribiremos nada en la nueva cadena. Fíjate que, más adelante, nos encontramos un carácter no espacio en blanco, ponemos la bandera a 0.
Como consideramos espacios en blanco espacios y tabulaciones, y no nos interesa que en la cadena nueva haya tabulaciones, no podemos hacer *des = *pos porque *pos podría contener una tabulación. Para evitar esto y hacer que se escriba un espacio hacemos que *des = ' ', es decir escribamos un espacio en el caracter *des.

Tal y como está planteado el código pon un campo más en el struct paciente que indique si está ingresado en el hospital o no. Para darlo de alta o ingresarlo modifica ese dato. La consulta de pacientes de un médico también debe usarlo.

Es un ejemplo para que veas que hasta en la librería estándar usan el mismo código que tu, y que tanto odia tu manual. En serio, tíralo.

En verdad no sé que manual estás siguiendo pero tíralo.
El programa está bien y, por ejemplo, así funciona la función de libreria fopen.

FILE *f = fopen(ruta, modo);

Date cuenta que tu función retorna la dirección de inicio del bloque que has adquirido de memoria. Lo único que tienes que hacer es no perderlo en ningún momento para pasárselo a free.

Mira si las fórmulas son correctas. Obtengo valores extraños y, al menos la fórmula de la ecuación de 2º grado que has dado en el enunciado está mal.

Algo así:

#include <stdio.h>
 
int tolower(int __c) {
    if(__c >= 'A' && __c <= 'Z')
        __c ^= 32;
    return __c;
}
 
int toupper(int __c) {
    if(__c >= 'a' && __c <= 'z')
        __c ^= 32;
    return __c;
}
 
int isblank(int __c) {
    return __c == ' ' || __c == '\t';
}
 
int main() {
    char cad[50];
    char *pos=cad;
    char *des=cad;
    int espacio_escrito = 0;
 
    printf("Ingrese la cadena: ");
    fgets(cad, sizeof(cad), stdin);
    puts(cad);
 
    while(*pos) {
        if(isblank(*pos)) { /* Trato de todo tipo de espacios en blanco */
            if(!espacio_escrito  && des != cad) { /* No se ha escrito el espacio en la cadena final Y no estamos en el primer carácter de la cadena final */
                *des = ' ';
                des++;
                espacio_escrito = 1;
            }
        }        
        else {
            *des = tolower(*pos); /* Todo en minúscula */
            des++;
            espacio_escrito = 0;
        }
 
        pos++;
    }
 
    *des='\0';
    cad[0] = toupper(cad[0]); /* Primera letra en mayúscula */
 
    puts(cad);
    return 0;
}

Puedes optimizar un poco el código, como ves pos siempre se incrementa, por lo que lo podrías sacar de los ifs.
Ya que el bucle principal recorre todos los caracteres del array mejor si solo manejas el control de los caracteres dentro de él y no generas más bucles, aparte de redundantes te quitan control y complican la lógica.
Te será más fácil si llevas todas las letras a minúsculas y ya fuera del bucle haces mayúscula la primera letra.
Ya existen funciones de librería para saber si un carácter es un carácter blanco y para cambiar la capitalización (solo en caracteres ingleses).

La idea es buena, pero vamos a ver los fallos.
Creas un array dinámico para alojar la inversa del array que pasas y te mueves en él mediante aritmética de punteros, haciendo que el puntero mismo vaya variando. Cuándo lo quieres liberar con delete has perdido el puntero original que apunta al inicio de bloque con lo que fallas. La solución es crear un puntero permanente que guarde esa posición y usar otro para moverte por el array, tal que así:

arrayPtr2 = new int[size];
arrayPtr2pointer = arrayPtr2;

Ahora usas uno para moverte como te movías y el otro para liberar con delete.

Para llevar arrayPtr hasta el final hazlo con una simple operación, así quitas código y tiempo de proceso:
En vez de

if (i == 0)
    for (int j = 0; j < size; j++)
        arrayPtr++;

usa

arrayPtr += size-1;

La orden para eliminar un array es mediante

delete [] identificardor_de_array

y no con

delete identificador_de_array

Las órdenes para preparar el array arrayPtr y para realizar la copia del arrayPtr2 al arrayPtr sácalas del bucle de generación del arrayPtr2. Son trabajos diferentes.

La función debería quedarte algo como esto:

void reverse(int *arrayPtr, int size) {
    int *arrayPtr2pointer = new int[size];
    int *arrayPtr2 = arrayPtr2pointer;
 
    arrayPtr += size - 1;
    for (int i = 0; i < size; i++) {                
        *arrayPtr2 = *arrayPtr;
        arrayPtr--;
        arrayPtr2++;
    }
 
    arrayPtr++;  // Necesario porque en el último bucle se actualizan estos dos punteros
    arrayPtr2--;  // y sobrepasan los limites. Hay que regresarlos a su lugar.
 
    arrayPtr2 = arrayPtr2pointer;
    for (int i = 0; i < size; i++) {
        *arrayPtr = *arrayPtr2;
        arrayPtr++;
        arrayPtr2++;
    }
    delete [] arrayPtr2pointer;
}

Si la función no es para estudiar punteros, ni memoria dinámica y es solamente para invertir un array puedes dejar a un lado todo esto y usar código más normal.

Incluye en tu código lo siguiente:

#define SWAP(X,Y) { \
    (X) ^= (Y); \
    (Y) ^= (X); \
    (X) ^= (Y); \
}
 
#define ARRAY_LENGTH(X) sizeof(X)/sizeof(X[0])
 
void reverse(int array[], size_t size) {
    int i;
    for(i = 0; i < size / 2; ++i) {
        SWAP(array[i], array[size - i - 1]);
    }
}

Pero la ruta la puedes escribir directamente y no tener que ir trozo a trozo. Así podrias usar hasta las rutas relativas y el programa en script msdos o de powershell.