Implemented stand-alone intepreter

The file mu.c implements a stand-alone interpreter which supports
running command line strings, executing files, and can be run
interactively.

There is a slight issue with Mu's grammar that makes the interactive
interpreting a bit wonky. In Mu statements and expressions are
completely seperated when parsing. This seperation is necessary to
prevent ambiguities that happen when not all operators are known.
For example "x >= 2" could be interpreted as "x = x > 2".
Unfortunately, it makes the most sense for interactive input to be
parsed as expressions, however this prevents a number of operations
such as assignments.

The current solution is to attempt expression parsing and if that
fails switch to statement parsing. This currently has an issue with
memory leaks but shouldn't be to hard to fix. Unfortunately this isn't
full-proof; expressions such as "x = 2" still parse as an expression
and it isn't until the operator "=" is lookuped that it fails.
A workaround for this is to use "let x = 2" which correctly drops down
to statement. To force the original behaviour, the statement can also
be forced like so: "{ x = 2 }". Unfortunately, without modifying the
grammar significantly, I believe this is the best solution currently.

Other options included defaulting to statement parsing and requiring
and explicit return to force expressions: "return x + 2". To make this
less annoying, the hardcoded operator "->" was added as an alternative
to return for statements. This operator was kept around as it leads to
a very nice lambdaish function declaration: "fn() -> 2".