Getting ready to switch to a one-pass generation of LLVM code.

We will do a separate typechecking phase and then generate
LLVM code *directly*. The main reason is simplicity. The current
code in Translate is very complicated. And while the generation
of the ANF intermediate representation is very beautiful, it is
not really useful for anything, since we do not do any type of
optimisation.

The module Typing will be in charge of typechecking and also of
computing which variables escape (are free variables of some
nested function) and of computing stack indices for these.

It already works on very simple example test/good/nested2.tig
Forgot to add Typedtree to last commit.

This is the output of the typechecking phase.
Internal representation of the LLVM code.

Instead of emitting LLVM code directly using the bindings,
we will generate this internal representation of the LLVM code first.

This will be useful to have for debugging and also is more satisfactory
because we are no longer completely dependent on the bindings
(in the future we could also emit a text file if we wanted).

The only tricky part is that when we emit LLVM code there can be
cycles related to phi-nodes. These are not represented in this
representation, so their handling is a little delicate.
Add emitter of LLVM code for the representaiton IL.

One has to be a little careful to emit instructions
in the 'right' order so that all variables are defined.
This can be done by doing a depth-first search of the
basic block graph. The only tricly point is that there can
be cycles related to phi-nodes (if there are no phi-nodes
there are no problems, because undefined variables cannot
appear in the body of any basic block in well-formed LLVM
code).

Basically when we see a phi-node we emit all the incoming
values that are defined at that point. And we save the undefined
ones and we backpatch them later. The algorithm is written
in a purely functional way, hopefully it works, but it has
not yet been tested.
Initial commit of a Translator for Typedtree => IL.

It compiles, but many functions are asserted out.
For the generation of IL we need to annotate Typedtree
with things like weather some expression is a ptr (and needs
to be GC'ed), return types, etc.
Typing produces correct Typedtree expressions again.
New pretty-printer for IL.
Initial commit of direct compilation strategy.

We are scrapping trying to do things with a LLVM-typed
intermediate language. Mantaining the types is just too
much work, so we are scrapping ANF and IL.

Instead after a typechecking phase we are emitting LLVM
direclty using the bindings.
Fix handling of IF nodes.
Fix handling of FOR nodes.
Improved typechecking/translation of records.

It still does not work becuase the translation from
Tiger types to LLVM types is not implemented for records yet.