Adding repl init-ns option to project file.
Adding initial support for non-CPS calls to CPS functions.

Each fn expression transformed by CPS now adds overloads that allow
for it to be called without a continuation argument. For example,
consider the (simplified) output of the cps macro for the identity
function:

  => (cps (fn [x] x))
  (fn my-fn
    ([x] (my-fn identity x))
    ([k x] (k x)))

The first overloaded version of the output takes a single argument,
the same as the original function, and makes a self-recursive call
to the overloaded version, which does take a continuation argument.
A similar so-called "compatibility" overload is added for each
original overload of the fn expression.

Note that this set of diff does not solve the "arity clash" problem,
such that overloaded fn expressions with arities that differ by one
generate overloads for both the CPS version of the first arity and the
compatibility one for the second arity. This leads to a compiler error,
since fn expression cannot have multiple overloads of the same arity.

For instance, consider the output of the cps macro for the following
function (which resembles the identity function that discards the
first argument in the second overloaded case):

  => (cps (fn ([x] x) ([x y] y)))
  Exception: can't have 2 overloads with same arity ...
  ;; Would have produced the following:
  ; (fn my-fn
  ;   ([x] (my-fn identity x))
  ;   ([k x] (k x))
  ;   ([x y] (my-fn k x y))
  ;   ([k x y] (k y)))

The CPS overload for the first arity has two arguments, as does the
original expression's second overload. The cps macro attempts to
generate both, triggering an exception in the Clojure compiler.
Adding partial fix for the arity clash problem.

This commit partially fixes the arity clash problem described in
the previous commit. When the arity of a CPS version of one fn
expression overload matches the arity of one of the original
overloads, a merged overload is generated such that it uses the CPS
version's parameter list, and the body of the is modified to become
an if expression that checks the first argument for the semi-unique
metadata tag attached to each continuation, and if present executes
the CPS version of the code. If the tag isn't present, the parameters
are rebound to the names of those used for the non-CPS version and
the compatibility call to the overload is executed.

For example, consider the following (simplified) transformation:

  => (cps (fn ([x] x) ([x y] (x y))))
  (fn my-fn
    ([x] (my-fn (with-meta identity {:tag true}) x))
    ([k x]
     (if (:tag (meta k))
         (k x)
         (let [y x
               x k]
           (my-fn (with-meta identity {:tag true}) x y))))
    ([k x y] (x k y)))

While these changes solve the problem of CPS vs. non-CPS calls for
fixed-arity overloading, it doesn't solve it for variadic functions.
Refactoring algorithm for CPS transformation on fn expressions.

The algorithm now delays creating fn-methods until it knows whether
it is a simple method (CPS-transformed or compatibility) or a hybrid
one. Note that this still doesn't handle variadic functions.
Updating docstrings and doing minor cleanup and refactoring.