Adding new simple-ops to prevent over-thunkification.

Several clojure.core operators were missing from the set of simple-ops
which would lead to over-thunkification of CTCO expressions and
therefore hurt performance.
Fixing handling of 'fn' in the parser.
Adding an algorithm to properly handle overloading 'fn' expressions.

One of the primary goals and main challenges of CTCO is to ensure that
code compiled with CTCO can inter-operate with other code and vice
versa. This is particularly important in the case of 'fn' expressions,
since we would like to preserve the number of arguments taken by a
'fn' expression so that outside code can use the same interface to the
function. We would also like to make CPS versions of 'fn' expressions
available so that mutually recursive functions transformed via CTCO
may call directly into the CPS versions of each, reducing function
call overhead.

Previously this was handled very poorly, as the prototype version of
the system only handled single-arity (non-overloaded) 'fn'
expressions, and only overloaded those functions created via 'defn.'

This update resolves that issue by overloading all 'fn' expressions to
maintain their original arity and add bodies for the CPS
versions. This includes new support for variadic functions,
transforming each overloaded function body. In essence, the original
arity versions are re-written to call into the associated CPS
versions. Since this transformation is done at the level of a 'fn'
expression, the recursive call to the CPS version is achieved by using
the optional name field for 'fn,' either using the existing name or
adding a unique one otherwise.

Of particular note is the case of overloaded functions in which there
are bodies which have arity that differs by one. For example:

	(fn
	  ([x] x)
	  ([x y] (+ x y)))

The problem arises from the fact that applying the CPS transformation
to the first body results in a new body which takes two arguments (the
original x argument and the new continuation argument), thus
conflicting with the preexisting second overloaded body. To handle
this, the representation of continuations has been updated to attach
runtime metadata to each continuation indicating that it is indeed a
continuation. With that change, the CPS tranformation for the 'fn'
expression proceeds by, in this case, rewriting the two-argument
version to do a runtime check for the metadata indicating that the
second argument is a continuation. If so, the CPS code for the
one-argument version is executed. Otherwise, the call to the CPS
version of the two-argument body is made.

This also warrants an update to the compiler's representation for 'do'
expressions, as they are used to generate the rewritten function
bodies in the cases where there is a conflict in the number of
arguments between the CPS version of one body and the preexisting
version of another. Specifically, this change necessitated that 'do'
expressions support the transformations following CPS. A future update
will add full support for 'do' expressions as part of the input
language to CTCO.

I try to avoid authorial insertion in my commit messages, but this
change brings me such great joy that I feel I can't avoid it. It
represents a shift in CTCO that makes it much more powerful and
generally useful for actual implementation. Seeing as though I'm
unfamiliar with other systems for applying partial CPS transformations
(i.e. not applying CPS to the entire program), I have not encountered
an algorithm that ensures interoperability with non-CPS code such as
this one. It may be the most clever trick I have devised in my
programming career.
Removing the (now useless) call to the overload mini-pass.
Converting remaining calls to (vec (map ...)) to reduce
Alphabetizing protocol implementations for App.
Adding implementations for PLoadTrampoline to each expression.
Removing unnecessary imports in util.
Removing unnecessary imports in utils.
Removing unnecessary imports in utils.
Pushing single-use let-binding into body.
Correcting namespace typo.
Restructuring PLoadTrampoline implementation around record types.

Previously tried to use compile-time metadata to indicate trampoline
entry points in function bodies that had undergone the CPS
transformation. For several reasons, not the least of which being that
Clojure records by nature are immutable and therefore get discarded
often when doing these sorts of transformations, the metadata was
harder to communicate appropriately than initially believed.

To combat this, two new record types were added: TrampMark and
Tramp. The former is introduced during the CPS transformations for
'fn' expressions to indicate which expressions represent points where
the trampoline needs to be loaded, and is replaced by the latter
during the load-tramp pass which inserts the name used for the
trampoline function.

Additionally, the generated code has been updated to include an
initial call to the (generated) trampoline.

Unlike previous versions of CTCO, this ensures that both initially
recursive expressions and calls to functions transformed by the
compiler are appropriately trampolined.
Removing now-useless overload mini-pass.
Removing long-useless PAbstractK and implementations.

Additionally updating project minor and revision number to reflect
advancement in overloading functions and removing unneeded
continuation application abstraction.
Pushing make-trampoline mini-pass into ctco.
Removing import for non-existent mini-passes.
Updating tests to reflect new representations.