SI-6286 IllegalArgumentException handling specialized method.

Specialize assigns SpecialOverride info to a specialized method
even when there is a further specialization that should be forwarded
to.
SI-7360 Don't let a follow-up TypeError obscure the original error.

When supplementing a fatal error message with context (current
compilation unit, tree, phase, etcetera), we must be cautious to
not to trigger another error which will obscure the original one.

Currently, `supplementErrorMessage` does its working a try catch
that only catches `Exception`. But this fails to catch
CyclicReferenceError (<: TypeError <: Throwable), as was seen
in a recent mailing list post by Greg Meredith.

This commit extends the catch clause.
Merge pull request #2389 from retronym/ticket/7360

SI-7360 Don't let a follow-up TypeError obscure the original error.
Merge pull request #2383 from vigdorchik/ticket/si-6286

SI-6286 IllegalArgumentException handling specialized method.
[refactor] Generalize SubstOnlyTM to multiple binders
Don't emit duplicate hoisted trees.

Relevant for test/files/pos/patmat_cse_nested.scala,
which is coming in a follow-up commit.
CSE must compare ReusedCondTMs by identity

CondTreeMakers that test the same condition were considered equal,
even though their substitutions may be different.
To make sure we don't accidentally equate CTMs when considering reuse,
now tracking them by identity -- ugly but safe.

The test file was derived from RedBlack, and was uncovered,
but not caused by the work on tuple matching.
Before, CSE didn't optimize RedBlack at all (I don't know why).
I can't think of a test case that doesn't rely on the new
tuple match optimizations, but wanted to get this fix out of the way first.
[refactor] Scrutinee encapsulates scrut's symbol & tree
[refactor] Simplify generation of default cases.

No need to thread along a function that generates the default,
just generate it immediately based on the scrutinee.
Optimize match that tuples only to then decompose.

```
(e1,...,eN) match {
  case (p1, ..., pN) if g =>
  ...
  case (q1, ..., qN) if g' =>
  case _ if g'' =>
}
```

is compiled by introducing the prelude

```
val x1 = e1
...
val xN = eN
```

and then referring directly to the `xi` that corresponding to the `i`th subpattern,
in the translation of the match, rather than selecting the `_i` component of the tuple.

This eliminates the allocation of the tuple and the indirection of accessing its fields.