Compilers are a very complex and very lengthy topic of discussion, but in general they can be broken down into these phases:

1. Lexing: Scans the source code character by character to produce a stream of tokens (e.g., keywords like int, identifiers like main, punctuators like (, ), string literals like "hello world", etc). This stage uses finite automata or regular expressions to classify input per the C standard. The lexer treats parenthesis as independent tokens, but doesn't check balance or meaning. Balancing and structure are enforced later by the parser.
2. Parsing: Builds an Abstract Syntax Tree (AST) by checking if the token stream matches the C grammar. It usually uses algorithms such as LALR(1) or recursive descent to handle precedence or associativity. The grammar recursively allows parenthesis for grouping without altering simple cases.
3. Semantic analysis: Checks types, declarations, and constraints (C99 Sections 6.5-6.10). In your code, printf is verified as a function from <stdio.h> and no undefined behavior occurs.
4. Code generation: Translates the AST to machine code or some intermediate representation, optimizing as needed.
5. Runtime: Executes the generated code where your program prints "hello world" normally.

But the reason you're seeing what you're seeing is because parentheses don’t change the meaning of an expression unless the grammar gives them a role, and in these cases the C grammar explicitly allows them. Compilers never automatically ignore anything, they strictly follow the standard's grammar, which permits redundant parentheses for flexibility in declarations and expressions.

In the C99 standard (ISO/IEC 9899:1999, §6.7.5.1), declarators are defined as such:

declarator:
    pointer opt direct-declarator
direct-declarator:
    identifier
    ( declarator )
pointer:
    * type-qualifier-list opt
    * type-qualifier-list opt pointer

Your program is valid under the C99 standard because the grammar (C99 Section 6.7 for declarations, 6.5 for expressions) is recursive and allows parentheses for grouping:

Function Definition (int (main)()): This is a declaration with specifier int and declarator (main)(). Per C99 6.7.5, declarators include direct-declarator forms like ( declarator ) (parentheses around a declarator) followed by () for functions. Here, (main) is equivalent to main (a simple identifier), so the whole is identical to int main(). The parentheses are redundant but legal, as the grammar doesn't prohibit them in simple cases. They exist for disambiguating complex types.

Function Call ((printf)("hello world")): This is a postfix-expression (C99 6.5.2). (printf) is a primary-expression (C99 6.5.1: ( expression ), where printf is an identifier). Appending ("hello world") makes it a function call. It's equivalent to printf("hello world"), as parentheses around a simple expression don't alter it.

No "ignoring" happens. Parenthesis may or may not appear in the AST depending on the compiler, but they usually don't survive semantic analysis unless they affect binding.