New branch for adding nicer constructor syntax. Modifying parser.

Parser now accepts constructor literals in case expressions. Also adding braces
around let and case bodies. Less ambiguous for a human to parse. May do layout
eventually, but for now, braces are fine.

Replacing single Case constructor in Types.Expr with ConCase and TagCase. The
concrete syntax only allows Constructors in alternatives, but the internal AST
will only used tagged alternatives.
Parser now accepts data specifications anywhere at the top level; they don't have to preceed super-combinators
Update pretty-printer to show program using new concrete syntax
Replace format* functions with instances of Format typeclass

Just implemented for concrete syntax. Haven't converted G-Machine state format
functions yet.
Make Transforms.Constructors convert DataSpec declarations into super-combinators

Something like

data List = Cons x xs | Nil;

Gets translated to

Cons x xs = Pack{3, 2} x xs;
Nil = Pack{4, 0};

The auto-generated super-combinators are eta-expanded because the Pack operator
can't be partially applied (but the super-combinators can be).
Make Transforms.Constructors convert case-expressions to use int tags instead of constructor names

map f ls = case ls of
    Cons x xs -> Cons (f x) (map f xs);
    Nil       -> Nil;

Gets translated to

map f ls = case ls of
    <3> x xs -> Cons (f x) (map f xs);
    <4>      -> Nil;

Also updated types so that lambda-lifting works again. May want to revisit
Expr type again. Maybe have a SimplifiedExpr type for post-transformation
programs.
Transformed code now executes on G-Machine. Still need to compile defaults (_ -> ...)
Cleanup parser; disallow wildcard pattern until compilation for it is implemented
Update README and add --prettyprint flag to show parsed code