products.Syntax: rewrite `tuple` helper

The new version is
* more regular itself (less boundary cases to reason about)
* produces more regular and straightforward output:

  - less differences between different arities. I could be convinced to
    special-case tuple(2) to be just Pair instead of its eta-expansion.

  - and no use of composeWithBuilder, which produces odd-looking
    variables named 'hole' because it residualizes the composition.
Refactor test

And remove leftover code.
ANormalization: Special case partial applications
Update worksheet results after special casing partial applications
Static caching: return all intermediate results

This still looks easy. Tested a bit in the worksheet.
A-normalization: ensure all application results are bound

That is, the innermost let body should not be an application node.

Maybe this does not matter for A-normalization, but it does matter for
the variant we're investigating, namely static caching.

The resulting code might be a tiny bit hacky: it ensures that the return
value of aNormalize is not an App node, so it's either atomic or a
lambda, but it does not make use of this assumption. However, this is
safe because aNormalizeTerm already knows to leave atomic terms
alone (if copyPropagation is enabled).
Disable QuickAndDirty
Invoke A-normalizer on produced programs/derivatives
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.