Drafting the CPS algorithm for function application.

Adding support for performing the Danvy-style CPS algorithm for function
application expressions with zero or more arguments. It differs from the
one implemented for clojure-tco both in its structure and the fact that
it actually works for non-trivial expressions, i.e. nested function
applications (this just goes to show how important test cases are
and how sloppy I was with some parts of the clojure-tco implementation).

The algorithm proceeds by first building two copies of the sequence
representing the original function application, one that is simply
reversed, and the other that is both reversed and has each expression
trivialized. An expression is trivialized by either a) applying the
CPS transformation if it is already trivial or b) replacing it with
a variable that will be used to represent it in a continuation.
Additionally, the algorithm maintains the current output expression,
which is initialized to the trivialized application expression in
the original (non-reversed) order with the initial continuation
expression inserted appropriately (for tools.cps, this means the
continuation is the second argument).

Then, then algorithm iterates over the two copies of the reversed
sequences of expressions in lock step. If the first expression is
trivial, the output expression is unchanged, and the algorithm iterates
to the next values for the expression sequences. If the first expression
is serious, a new output expression is created by applying the CPS
transformation to the first expression with a continuation constructed
with the first item of the trivialized expression sequence as the
argument and the previous output application expression as the body.
Using the CPS version of the expression as the new potential output, the
algorithm iterates over the remaining expressions.

In addition to the new CPS algorithm, some unused code is being removed
and minor edits to existing code based on previous comments are being
performed.