Snapshot before the great dive.

Fixed operator precedence (it couldn't work by using an non-terminal
operator), added most rules.
Internal boolean type and the two boolean constants true and false,
avoids unnecessary conversion of boolean values to float.
Unary and binary operators, performs the right conversions on the
operands when needed.
if and while statements implemented, grammar rules for for loops in
place.
Started to implement [expression] in identifiers.

Now, the code doesn't even compile, and I'm not sure whether to go
further or not.
By attempting to avoid duplicate code in Identifier and Assignment's
methods, I'm afraid to have reached the limits of C++. Uniting the
common code in a function template was manageable for
Identifier::Codegen and Assignment::Codegen using some fairly ugly
quirks, but to use the same template for Identifier::RuntimeType I would
have to multiply by three the amount of quirks. All of this could have
been avoided if C++ supported conditional code evaluation, that is to
say true metaprogramming and not only metaprogramming limited to types.
Unfortunately Bjarne Stroustrup and other core deciders of the design of
C++ have stated their opposition to the concept of "static if" in this
paper:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3613.pdf

One of the only language to support conditional evaluation of code is D,
and their users are bewildered by the reasons invoked in this paper:

http://forum.dlang.org/thread/cdgzdesltjefjvnjbspk@forum.dlang.org

D has some very tempting features and only a few drawbacks (GC,
LLVM/Ogre/... are written in C++), I'm now seriously considering
switching to it.
This commit is a souvenir, in case my tinkering with D proves fruitful.