Introduce ANF as intermediate language.

This module Anf will take the place of Typedtree2 later on.

The reasons to introduce a new intermediate language are
varied. The main one is aesthetic. The current intermediate
language is a very inelegant statement oriented language.
In particular the current intermediate language does not get
me access to all the features of the SSA language that underlies
LLVM (such as PHI-instructions). We could have used a language
that was closer to LLVM's, but then it is very hard to mantain
the scoping information for inner functions that we need to
perform Lambda Lifting (that we do after translation into the
intermediate language). The solutions is ANF, Administrative
Normal Form. It is the functional equivalent to SSA. We could have
also used CPS (Continuation Passing Style), but it is simpler to
generate LLVM code from ANF. The key feature is that it provides
for local blocks (like local function definitions, but that can
only be called in tail position). They correspond to basic blocks
in SSA. Its arguments correspond to PHI-nodes. All of this is
nicely explained in A. Appel's paper 'SSA is Functional Programming'.
An LLVM code emitter for the ANF language.

This will take the place of EmitLlvm later on.
Rewrote Typecheck2 to use the new ANF-based IL.

Also added a pretty printer for the ANF language,
in Pr_anf.
Add fix to avoid bug in LLVM OCaml bindings.

As they are right now, the build_phi instruction
in module Llvm takes a list of incoming values and predecessors.
This list must be non-empty (as it is used to deduce the type
of the phi-instruction).

This means that we cannot emit a new basic block (with no
predecessors) when we see a LET_BLOCK expression. Instead, we
have to wait until it is invoked at least once so that we can
provide a non-empty list of incoming values.

In order to delay the emission of the LET_BLOCK block until we
see a corresponding GOTO expression, we must save the context
(benv and venv) in which the body of the local block must be
emitted; see Emit.block_info and Emit.goto.

All in all, a horrible hack.

I also fixed a somewhat related bug in the emission of code for IF nodes.
It produced garbage if we had a expression of the
form IF (..., GOTO (bl, ...), GOTO (bl, ...)). This type of expression
gets produced for the Tiger program x := (if ... then ... else ...).
The problem is that the corresponding phi node in bl only had 1
predecessor, but two different values! So we must split the two branches
of the IF into different basic blocks and only then jump to bl. The
reason for the original implementation was to optimise (!) the basic
block cfg.  Let this serve as a warning for the future.
Added Immutable flag to variables.

This is only used for iteration variables in FOR loops.
But it is crucial because otherwise the generated LLVM
code was not working (since iteration variables are immutables
we do not alloca them, just keep them in registers - so we must
remember not to LOAD them to get their values!).