Add a generic call-signature type, via a type-level uncurry function!

Getting this to type check was pretty rough, but I'm quite happy with
the eventual solution.  Also, I'm using type-level strings to get
unique signature types and recover a value-level string, without
having to duplicate the string at the value level.  This is a minor
savings in practice, but it's cool that it works (via Iavor's TypeLits
extension).
Add notes on printing tree-command style fancy ASCII trees.
Add most of a simple logger.

From the comments:

  ----------------------------------------------------------------
  -- An event logger with a simple interface.
  --
  -- Specify the function you want to trace, along with a 'Symbol' to
  -- uniquely tag it (not implemented here), and get back a tracer for
  -- your function.  The pattern for lightweight logging is then
  --
  --   f :: t
  --   f = e
  --
  -- becomes
  --
  --   f , f' :: t
  --   f = simpleLogger "f" f'
  --   f' = e
  --
  -- creating a knot, where recursive calls in 'e' are still to 'f' and
  -- hence trigger recursive logging.

The handling of 'Symbols' and related creation of 'SimpleCall'
signatures is not implemented yet, but that part should be relatively
simple. Here we have the implementation of a "collecting" call that
wraps a function so that it's accumulated (uncurried) parameters get
returned with it's result.  E.g. a function of type

  a1 -> ... -> an -> m r

turns into a function of type

  a1 -> ... -> an -> ((a1 , (...(an , ()))) , m r)

internally, and then the accumulation of arguments

  (a1 , (...(an , ())))

can be used to construct a 'BeginCall' log event.

The current version combines the accumulation with the logging, but it
might be nicer to abstract out the pattern into a separate collection
function that's used by a simpler logging function.  However, that
might complicate the types even more ... we'll see.
CP: factor out "call while collecting curried arguments".

The previous commit added 'simpleLogger' and friends which combined
generic logging with generic transformation of functions to accumulate
their arguments.  I'd like to separate those two pieces.  Here's a
start, but I'll need to use an accumulator as in
'SimpleLogger.Collect'.
Move curry code into it's own file; update imports.

There are now conflicting definitions of 'Collect', but I'll work on
that next.
Delete identity monad related code.

I don't think the identity monad is actually useful here, since we
want monads that we can log to.  If we ever do want to add it back the
recipe is simple: just adapt the 't m r' (transformer) instances.
Add 'collectCall' that collects the curried arguments on an uncurried call.

Turns out this is probably not sufficient to implement 'simpleLogger'.
What I really need is a proper continuation.  Then this 'collectCall'
will become a special case of a general "collect and call
continuation" function.
Implement general "collect and call continuation" function.

It's much more elegant than the more specialized versions, and should
be able to derive them :D
Move simple modules into into Simple folder.
Update module names for move in last commit.