Why the external "x" is used?

You've mixed two base concepts here: visibility and extern declarations.

Visibility refers to the resolution of variable names: when there are multiple declarations of the same name, the compiler will use the one of the innermost scope. In your first example that is the line extern int x; In your second example the two declarations are in the same scope, but in this case the later one hides the former ones. this causes the error

Note that it does not matter whether this declaration contains extern with respect to visibility rules: in any case this declaration effectively hides the declaration above: int x = 4;

extern tells the compiler that you are referring to a variable declared elsewhere in (or possibly outside) your codebase. That may be within the same, or a different compilation unit. In any case, that variable declaration must be in the global namespace, so a local definition within your function func() will not be usable as an extern. therefore there is only one variable declaration usable as an extern in your first code example, and that is the first one. The second example contains no global definition for x however. therefore the system* cannot resolve what your declaration extern int x; refers to, and that causes the error.

(*: I would expect the linker to issue an error here; not sure why you said the program does - or did you mean the linker?)
[edit]fixed[/edit]

The reason you can't do away with the curly braces is to do with scope. A named variable refers to one previously declared in the same scope, or closest outer scope. You can have variables with the same name in different scopes (they don't even have to be the same type), in which case the one currently visible (eg declared in the same or closest outer scope) hides the others.

Put simply, the extern keyword in this case tells the compiler to use the "x" declared in the global scope, not the one closest.

int x = 5; // Global scope

int func()
{
  // At this point, "x" refers to the global, with value 5
  int x = 4;
  // A local "x" has been declared in this scope, so it hides the global
  {
    // New scope, closest declaration (x=4) is still the visible one
    extern int x; // Now "x" refers to the global
    return x;
  }
}

If you throw away the braces, you have two "x" in the same scope - both the local and the global - and that is an error.