Supongo que con este te irá bien.
Va comprobando desde la primera hasta la penúltima columna si las siguientes son iguales a ellas. En cuánto detecta que dos elementos no son iguales va no pierde más tiempo y va a buscar la siguiente columna. Si detecta que dos columnas son iguales se detiene e informa de ello.
Hay que usar stdbool, pero se puede cambiar el bool por int y true y false por 1 y 0 respectivamente.

bool columnas_iguales(int matriz[][COLUMNAS]) {
    bool retval = false;
 
    for(int i=0; !retval && i<COLUMNAS-1; ++i) {
        for(int j=i+1; !retval && j<COLUMNAS; ++j) {
            int m;
            for(m=0; m<FILAS; ++m) {
                if(matriz[m][i]!=matriz[m][j])
                    break;
            }
            if(m==FILAS)
                retval = true;
        }
    }
 
    return retval;
}

stdin no és un archivo de texto al uso. Se ve como archivo por la forma en que UNIX maneja los componentes de la máquina (cómo se ha dicho C se creó para programar UNIX y tiene esas reminiscencias).

stdin es un stream así que no tiene final: se vacía a petición del S.O. pero se llena por circunstancias ajeno a él. De alguna forma siempre se está en el inicio de stdin.

Al decirle a fseek que vaya al final de stdin lo que se hace es ir al final del buffer, entiéndase el final en ese justo momento, pero lógicamente se vuelve a encontrar en su posición inicial listo para llenarse de nuevo con cada nuevo dato que se entre.

Imaginaros una cola se escribe por el final y se lee por el principio. Ahora imaginaros que podéis mover el puntero de lectura con fseek al final. Todo lo que hay al inicio desaparece y la cola aparece vacía.

Me he tomado la libertad de refactorizar tu función y me ha quedado algo así:

setClientes eliminarClientes (setClientes variosClientes ) {
    bool encontrado = false;
    int i;
    char entradaDatos[22];
 
    const int tamNumCuenta = 10;
 
    switch(menu1()) {
    case 1:
        leerCadena("Introduzca el DNI\n", entradaDatos);
        for(i=0; i<variosClientes.numClientes; i++) {
            if(strcmp(variosClientes.Clientes[i].DNI, entradaDatos)==0) {
                encontrado = true;
                break;
            }
        }
        break;
 
    case 2:
        leerCadena("Introduzca el numero de cuenta\n", entradaDatos);
        if(strlen(entradaDatos) != tamNumCuenta) {
            cout<<"El número de cuenta introducido no tiene el formato correcto."<<endl;
        }
        else {
            for(i=0; i<variosClientes.numClientes; i++) {
                if(strcmp(variosClientes.Clientes[i].numCuenta, entradaDatos)==0) {
                    encontrado = true;
                    break;
                }
            }
        }
        break;
    }
 
    if(encontrado) {
        cout<<"\nEl cliente ha sido eliminado del sistema";
        for(int j=i; j<variosClientes.numClientes-1; j++) {
            variosClientes.Clientes[j] = variosClientes.Clientes[j+1];
        }
        --variosClientes.numClientes;
    }
 
    return variosClientes;
}

Puede haber errores, no la he probado.
Parte importante: pon el prototipo int menu1(); fuera de la función, justo después de los includes. Los prototipos no se ponen dentro de las funciones, se puede pero muy mala práctica.
He quitado los bucles porqué no querrás que tu cliente se encuentre en un bucle sin fin si le han pasado un DNI o cuenta que no está en la tabla y se vea obligado a eliminar una entrada buena sólo para que el programa siga ejecutando.

Por otra parte: recibes toda la estructura de datos y devuelves toda la estructura de datos. Depende de lo grande que sea eso es mucho movimiento de datos. Te convendría usar referencias o punteros.
Además: a menos que copies en otro sitio una la nueva estructura modificada te convendría hacer que la función modificara la estructura del argumento directamente.

Como primera orden del if tienes una comparación, no una asignación
Lo que haces ahí es comparar x con false y el resultado se pierde. No se cambia el valor de x. Es decir: en vez de == debe haber =.

Para evitar tu próximo posible fallo lógico:
Las dos cadenas a comparar deben ser exactamente iguales
 Es decir que si numCuenta tiene un salto de línea porque lo has capturado con un fgets (y esa función obtiene saltos de línea) y comparacionCuenta no tiene saltos de línea o viceversa, las dos cadenas no serán iguales y la comprobación fallará.

Tu fallo puede estar en esta línea, de hecha en esta línea hay un fallo gordo que suele pasar desapercibido:

Si te fijas asignas true a x: x=true

Para evitarte esto: cuando se evalúa una variable para C o C++ devuelve false si de alguna forma vale 0 (que valga false, 0, NULL, '\0'), para todo lo demás vale true.

Todo esto viene a decir que lo podrías haber escrito:

Veo que conoces malloc así que no hay problema en que uses memoria dinámica.
A la hora de generar el array házlo de forma dinámica.
El prototipo de la función que recibiera tu array sería éste:


Esto es así porqué si le pasas un array estático estás obligado a darle todas las dimensiones menos la de mayor peso. Esto es así porque C necesita conocer el tamaño de los objetos que va a usar, y cómo se escapa de la explicación de esta respuesta te lo tendrás que creer.

Ahora llega la hora de crear el array. Suponiendo que el número de filas ya está en n_filas y el número de columnas ya está en n_columnas, lo dimensionas de esta forma:


A la hora de darle un dato a una posición cualquiera del array suponiendo m el número de fila, n el número de columna y x el dato a guardar:


Lo mismo que para mostrarlo:


Y a la hora de pasar el array a la función:


Ahora pensarás:
Pero si C necesita saber el tamaño de un objeto para poderlo usar ¿Por qué se le pasa mi_array sin dimensión alguna, en vez de hacer mi_array[][20], por ejemplo?

La respuesta es que todos los punteros tienen el mismo tamaño. Todos.

Así que te aseguras, de esta forma, que puedes pasarle a esta función un array con un tamaño arbitrario de sus dimensiones que te va a funcionar siempre que los valores que le pases a filas y columnas sean los que realmente tiene dicho array.

Muy importante, eso sí, cuándo dejes de utilizar el array debes liberarlo y eso se debe hacer desde dentro a afuera. Así:

Edita el post y pon el código entre etiquetas GeSHi. Las tienes justo encima de la caja de texto.

A raíz de este post me he puesto a pensar en todo esto.
Ya que C viene del UNIX y en UNIX todo son archivos y por tanto stdin es un archivo ¿qué tal si llevamos el puntero de stdin hasta el final y nos saltamos todo lo que hay dentro?

Al menos en MinGW64 funciona. Faltarían más pruebas con otras bibliotecas y S.O. para corroborar.

#include <stdio.h>
 
int main() {
    char c;
    while(1) {
        printf("> ");
        c = getchar();
        fseek(stdin, 0, SEEK_END);
        printf("Caracter: %c\n", c);
    }
}

Incluso acepta una única pulsación de intro.

¿Esto no debería estar en C/C++?

Lo veo bien. El único cambio que haría sería quitar el promedio de la estructura porque siempre debe depender de los parciales. Si se guarda como un dato se podría modificar y por tanto falsear. Si no existe se obliga a calcularlo cada vez que sea necesario y por tanto es una garantía más de que sea el que toca.