Why does "dangling-else" emit a warning?

Indentation doesn't matter in C. Each of the following is exactly identical:

if a()
if b()
foo();
else
bar();

and

if (a)
  if (b)
    foo();
  else
    bar();

and

if (a)
  if (b)
    foo();
  else
    bar();

The compiler is warning you that this appears ambiguous to humans, and you should explicitly add braces to make your code obvious.

Edit: As noted in a comment, my answer makes it clear that indentation doesn't matter, and doesn't help disambiguate which if the else was intended to belong to.

It's worth mentioning that it's not only leading indentation but all whitespace that doesn't matter. C (and most languages based on C syntax) makes no difference between spaces, tabs, and newlines.

Here are a few more versions that are exactly identical to the above versions:

if (a) if (b) foo(); else bar();

if (a)
  if (b) foo(); else bar();

if (a)
  if (b) foo();
else bar();

Again, there is no ambiguity for the compiler here, but many humans will struggle to understand where the else goes.

OP states: "and prefer to avoid braces when possible (for readability)"

This leads to examining the flow of the presented code. For readability, this flow could be expressed without recourse to else, dangling or not:

int
read_n(char *cp, int n)
{
  int nread = read(STDIN_FILENO, cp, n); // simply expressed (ie. not nested in an 'if')

  if (nread == n) // desired result
    return n;

  if (nread != -1) // suboptimal result, but not total failure
    return nread;

  // react to complete failure
  die(DIE_ERROR_FMT, "failed reading input");
  return -1; // or is execution already stopped?
}

A sprinkling of comments and a simple flow of logic make this routine easier to understand. This skirts the issue of any dangling else.

> Why does "dangling-else" emit a warning?

Because sometimes code like this is written by mistake:

if (A)
    if (B)
        C;
else // Intended to apply to A but applies to B.
    D;

The compiler recognizes the pattern and cannot be sure whether or not there is a mistake, so it warns you.

This is unlikely to occur in simple code, but consider:

if (A)
    if (B)
    {
        Several dozen lines of code…
    }

In this case, the person who adds the else later on, intending it for the A, might not see the intervening if for B when they are adding the else. It might be scrolled out of their editor window. So, when the compiler sees this pattern, and the dangling-else warning is enabled, it warns you.

(It might be nice if the compiler considered indentation, and, if the indentation were consistent throughout the program and the indentation of the else were consistent with its matching if, did not emit this warning.)