XXX Disable typechecking in Let (to revert)

Dangerous! But I need this to experiment with static caching, right now
I have no idea of the needed types.
Static caching: try to adapt callers (WIP)

This is trying to adapt callers of a function to use only the first
element of the returned tuple.

However, right now I need to duplicate lots of code from
ANormalFormStateful to override some parts. That's because I'm mixed in
together with it, but I want to keep the original functionality also
available.

So, stopping here and changing the structure to use a bit more
composition.
Misc worksheet output changes
Switch ANormalForm from inheritance to composition

This means a lot of changes; in particular, since we are using
path-dependent types, this requires switching to sharing constraints.

Once you know what to look for, it's possible to encode them, but type
inference does not really want to infer the right types.

This is partially "my fault" though - see next commit. Not that one
could guess.
ANormalFormSpec bugfix: don't call addCaches

This was introduced in 8b39566571ae3910fec1a1f82defcbf1a01b305f.
addCaches is not ready for prime-time yet, so it shouldn't trigger
failures in existing tests.
Sharing constraints with less type annotations

Look at all those type annotations going away in the commit:

```
-  val aNormalizer: let.ANormalFormStateful { val mySyntax: outer.type } = new let.ANormalFormStateful {
-    protected val mySyntax: outer.type = outer
+  val aNormalizer = new let.ANormalFormStateful {
+    val mySyntax: outer.type = outer
```

The old type is now inferred automatically, including the refinement for
`mySyntax`. It turns out this did not happen before just because
`mySyntax` was protected. This sort-of makes sense, but the error
messages you get are less than helpful - in this situation, Scalac
should arguably give you a warning.

This commit also `mySyntax` public at the original declaration site:
that's not needed, but it ensures that all overriders become public.
Static Caching: Add new worksheet
Cleanup code sharing between ANormalFormStateful and AddCaches

Now that they don't need to be mixed together, we don't need to be
careful with name clashes, or with clashes on the state of the fresh
variable generator.

This also means that aNormalizeName now calls the old addCaches, as I
wanted, but this seems to cause uninteded breakage. So probably that was
not a good idea, but now at least I can control this better.
AddCaches: Avoid trying to produce unary tuples

This came up because aNormalizeName is misbehaving as before (trying to
save caches too often).

However, I guess this fix will be generally useful.
Generalize Traversals.orIdentity, define or
Refactor aNormalize using Traversals
build.sbt: Reduce dependencies from bigClients

bigClients just needs clients main code to be compiled, but does not
need to wait on its tests.
Apply substitutions to saved bindings

Might fix bugs with A-normalization in existing examples.
Actually fix substitution in A-normalization

The problem was that when descending into function bodies, the current
substitutions were not propagated inwards. Now they are propagated both
inwards (which is much better) and outwards - which is fixed in next
commit. (Here it still seems to work because there is not enough
shadowing to trigger the problem, but I'm not sure if this is
guaranteed).

This fixes the compile errors in clients and bigClients; the transformed
programs now give the correct results.

This also reverts the previous fix, which acted in the wrong place:
terms are traversed inwards, and when a term is saved the bindings it
uses have already been fully processed, so no further substitution is
needed. This is nice because it avoids doing a second pass over the
term.
Propagate substitutions only inwards, not outwards

The previous commit propagated substitution inwards and outwards using a
mutable Map. Now make instead the reference to this map mutable, but the
map itself immutable. This way, whenever we descend into a function, we
inherit existing substitutions, but don't propagate them outwards.

Types must be updated quite often, but most actual code works unchanged,
because now
  myVar += el
is desugared to
  myVar = myVar + el.

Tests keep passing :-)