Parenthesized identifier of a variable in C

I am interested in how the compiler parses certain declarations and why does it allow them in the first place.

Consider the following shred of code: int(var);

which most likely nobody would ever write, but it appears to be allowed by GCC C99 for some reason (a language extension?).
To me, knowing exactly how the declarations are parsed, this makes sense albeit useless and an obvious bad practice in the slightest.

The problem is that this introduces a new difficulty in parsing declarations as such:

int func ( int(var), int(void) );

Here, since identifiers in argument declarations are optional, the compiler must do what exactly? Attempt to retrieve 'void' as an identifier, but instead of producing an error as usual, allow it since it matches the syntax of a function (void) returning int?
This presents a challenge when you would want to parse such a declaration and I want to make sure I am doing it correctly.

It starts to make less sense and become more confusing with declarations like this one:

void c (int())

Because the argument will be treated as a function returning int instead of

void c (int);

Please, shed some light on the subject.

According to the C grammar (6.7.6 Declarators)

Syntax
    1 declarator:
        pointeropt direct-declarator
    direct-declarator:
        identifier
        ( declarator )
    //...

declarators may be enclosed in parentheses.

For example this array declaration

int a[M][N];

may be rewritten like

int ( ( ( a )[M] )[N] );

As for this function declaration

int func ( int(var), int(void) );

then there are declared two parameters: one named parameter of the type int and other unnamed parameter of the function type int ( void ).

In C in function declarations that are not at the same time their definitions you may omit identifiers of parameters.

As for this declaration

void c (int());

then again the parameter has a function type.

Parentheses are allowed in declarations because they are needed to create certain compound types, such as:

int *x[3];    // An array of 3 pointers to `int`.
int (*x)[3];  // A pointer to an array of 3 `int`.

Using int (x) is merely using the allowed grammar in a way that is needless.¹

> This presents a challenge when you would want to parse such a declaration and I want to make sure I am doing it correctly.

The C grammar is generally not parsed by studying the grammar rules and manually writing code for it. Parsing theory, generally taught in university computer science curricula, studies formal descriptions of programming languages and mathematical transformations of a formal language grammar into software that parses the grammar. There are software tools to perform this transformation.

Yacc is one such tool, often paired with Lex to do lexical analysis. With Yacc, you would write grammar rules, much as they appear in the C standard, and accompany them with source code to process the parsed tokens, and the Yacc tool would transform the rules into parsing source code.

Footnote

¹ Parenthesizing identifiers in simple declarators is not entirely useless. One use is in writing Stack Overflow questions for a certain date in the spring of the northern hemisphere.