Add heterogeneous map 'hmap' in terms of 'HFold'.

And remove useless type param from 'HFold', and use 'hmap' to
implement a generic call formatter.  This is a small step towards a
generic processor instance ...
Expose the heterogeneous container type 'H'.

It's not actually used in the 'ConstraintLogic' module for anything
that matters, so it should probably be moved ...
Add a comment.

I had forgotten why I put the function name in the 'SimpleCall' type
in the first place :P
CP: Add the 'HetCall' call and the translation function 'heterogenize'.

The 'HetCall c tag' is a 'Signature' for which all parts are wrapped
in 'H c'; the idea is to facilitate generic processor instances which
use the constraint 'c' to pretty print the contents, but which don't
care which particular function is being processed.  The simplest case
is probably to make 'c ~ Show'.

The 'tag' is there so that we can write more than one processor
instance for the same class 'c'.  E.g., the library could provide a

  UnixTree (HetCall Show "default")

instance and a user could write there own

  UnixTree (HetCall Show "my fancy instance")

if they didn't like the default.
Move 'HFold' into HetCall.hs.

May still want to move 'HFold' again later, but this is a better place
than the test file :P
Add 'HFold c [H c]' instance and 'unH' for processing 'HetCall's.

In a 'LogTree (HetCall c t)' node all the parts are wrapped in 'H c's,
with the args in a '[H c]'.  The 'unH' function abstracts the only
reasonable thing you can do with an 'H c' value: unwrap it and apply
some function that uses the constraint 'c'.  The 'HFold c [H c]'
instance is essentially a regular fold where the folding function is
appropriately composed with 'unH' to go under the 'H c's.
Add 'HetCall' tests: generic 'UnixTree (HetCall Show "default")' instance.

This example shows a very reasonable level of overhead suffices: if
all the parts satisfy 'Show', then the user only needs to insert the
'SimpleCall' stubs!  Adding a preprocessor that automatically inserted
the stubs would be even more convenient ...
Parenthesize arguments when necessary in 'formatCall'.

Using a heuristic ...
Add two 'UnixTree (HetCall Show tag)' processors.

They are "header" and "oneline", and are more compact than the
existing "bracket" version.  They reveal that I haven't handled the
case of empty body and footer correctly in 'UnixTree.layer' ...
Improve 'UnixTree' output when body and footer are empty.

Now, when the body and footer are empty, the last line of the header
is formatted specially.  The case of a single-line header is handled
specially.

Examples
========

These are three different 'UnixTree' formattings of the same trace.

Single-line headers:

  ┬ <()> h (Just 6) = <error: there>
  └─┬ <()> f 6 = <error: there>
    └─┬ <()> f 5 = <error: here>
      └─┬ <()> f 2 = "XX Y" <()>
        ├─┬ <()> f 1 = "X Y" <()>
        │ ├── <()> f 0 = " Y" <()>
        │ └── <()> g "X" " Y" = "X Y" <()>
        └── <()> g "X" "X Y" = "XX Y" <()>

Multi-line headers:

  ┬ ()
  ├ h (Just 6) = <error: there>
  └─┬ ()
    ├ f 6 = <error: there>
    └─┬ ()
      ├ f 5 = <error: here>
      └─┬ ()
        ├ f 2 = "XX Y"
        ├ ()
        ├─┬ ()
        │ ├ f 1 = "X Y"
        │ ├ ()
        │ ├─┬ ()
        │ │ ├ f 0 = " Y"
        │ │ └ ()
        │ └─┬ ()
        │   ├ g "X" " Y" = "X Y"
        │   └ ()
        └─┬ ()
          ├ g "X" "X Y" = "XX Y"
          └ ()

Headers and footers (this style is unchanged by this commit):

  ┬ ()
  ├ h (Just 6)
  ├─┬ ()
  │ ├ f 6
  │ ├─┬ ()
  │ │ ├ f 5
  │ │ ├─┬ ()
  │ │ │ ├ f 2
  │ │ │ ├─┬ ()
  │ │ │ │ ├ f 1
  │ │ │ │ ├─┬ ()
  │ │ │ │ │ ├ f 0
  │ │ │ │ │ ╞ " Y"
  │ │ │ │ │ ╘ ()
  │ │ │ │ ├─┬ ()
  │ │ │ │ │ ├ g "X" " Y"
  │ │ │ │ │ ╞ "X Y"
  │ │ │ │ │ ╘ ()
  │ │ │ │ ╞ "X Y"
  │ │ │ │ ╘ ()
  │ │ │ ├─┬ ()
  │ │ │ │ ├ g "X" "X Y"
  │ │ │ │ ╞ "XX Y"
  │ │ │ │ ╘ ()
  │ │ │ ╞ "XX Y"
  │ │ │ ╘ ()
  │ │ ╘ <error: here>
  │ ╘ <error: there>
  ╘ <error: there>