Remove OP_UMINUS.

Instead we use binop('-', 0, expr).
Compile while loop in parser, removing AST_FOR.

This is going to be one of a series of patches to represent complex control
statements (such as for, while or do-while) with simple ifs and gotos.

The aim of doing that is to reduce the complexity of the code generator.
The code generator is probably the most messy piece of code in 8cc.
That has many bugs related to correctness. I want to improve that.
But before doing that, I wanted to move the stuff that's not really a part of
code generation (resolving break jump targets, etc.) out of the code generator.

Reducing the number of AST types makes it easy to write a walker for that.

Another upside is that we check for stray break/continue/case statement errors
earlier.

A downside of doing that is to lose the information about details of
the original source code. We are no longer able to say if a for loop ever existed
in the source. If we really want to avoid the downside, we could keep the parser
as is, and instead write a new pass to convert the original AST to the
for-expanded version of the AST. Nothing's wrong with that, but it needs a new
AST walker. I decided to not take the path in preference to simplicity.

Now, the following code

  while (expr)
    foo();

is read as

 BEGIN:
  if (!expr) goto END;
  foo();
  goto BEGIN;
 END:
Convert for.

  for (init; cond; inc)
    body;

is compiled to

  init;
 BEGIN:
  if (!cond) goto END;
  body;
  inc;
  goto BEGIN;
 END:
Convert do.

  do {
    foo();
  } while (expr)

is compiled to

 L:
  foo();
  if (!expr) goto L;
Convert switch.

  switch (expr) {
  case 1:       foo(); break;
  case 2 ... 5: bar(); // fallthrough
  default:      baz(); break;
  }

is compiled to

  int tmp = expr;
  if (tmp == 1) goto L1;
  if (2 <= tmp && tmp <= 5) goto L2;
  goto DEFAULT;
 L1:
  foo();
  goto END;
 L2:
  bar();
 DEFAULT:
  baz();
  goto END;
 END:
Write macro names in uppercase.
Simplify.