Teasing apart the parser in prepartion for the internals redesign.

Previously, parser had a monolithic design that lumped all
CTCO-accepted expressions together. The immediate difference with the
new design is that accepted expressions are now grouped by type
(e.g. simple, core form, composite form, function application,
etc.). In the long-run this will also reflect the move to representing
fewer internal forms by transforming composite forms into core
representations.
Simplifying and coalescing code in the Defn record type.

Previously the code for emitting "defn" contained a special case for
when only one arity was given, ensuring that there were no parentheses
around the formals list and body expression(s). This was a silly waste
of time just to make semantically equivalent code look prettier. Now
the emitting code unconditionally outputs the function bodies within a
Defn as a list.

Also removing the unnecessary "let" binding within walk-expr.
Changing mini-passes to operate on sequences instead of records.

Previously caused much heartache by creating and manipulating CTCO
records later in the compiler (i.e. mini-passes). Writing the passes
this way made them brittle to changes in expression
representation. Plus, after creating all those record definitions,
they were immediately unparsed into the final expression.

Overall, the original implementation was a very silly choice. We
should all be glad that it's been corrected.
Changing representation of fn to match Clojure's version.

Previously, the CTCO representation of fn was a stripped down version
of the one used in Clojure. The underlying record can now represent
all the forms usable in the Clojure fn form.

Note that the full set of forms for fn is not yet supported by
CTCO. The underlying representation can accept it, but the parser
needs to be updated to handle it correctly.
Updating tests to match new CTCO representation.
Changing the name of PEmit/emit to PUnparse/unparse.
Adding a nifty extend-group macro

Many of the CTCO expression records have common implementations for
their protocols and make use of extend...repeatedly. Tonight I finally
recognized that this was screaming for a macro, and it turned out that
macro didn't exist. Well now it does, in the form of extend-group in
util.clj. It's not actually used yet, but should be propogated through
the expression record definitions.
Adding 'def' to the accepted language forms in CTCO.
Adding use of extend-group macro to relevant record definition files.
Updating project version number.

Attempting not to suck as badly at semantic versioning.
Removing the Defn record type from CTCO.

Previously the compiler represented (almost) each supported language
form as a separate record type. Steps are being taken to strip back
the number of internal record types to use few more than what are
considered the "core forms" of the Clojure language. In order to
support a wide array of expressions, it falls to the parser to
reexpress those expressions in terms of semantically equivalent core
forms.

The removal of the Defn record is the most major step in this
direction. Rather than having an explicit internal representation, the
parser now parses defn expressions in terms of def and fn.
Updating project version.