Optimize handoff namer -> typer tree handoff

Use tree attachments, rather than a global hashmap, to record
the results of computing inferred types in Namer.

For cases when no transform occurs (the typer mutates a Literal
tree in-place by just setting its type), this leads to a minor
change in behaviour in the interaction with plugins: they will
be asked a second time to amend the type. This stems from the
fact that types uses a lazy tree copier.
Optimization in Uncurry

Only perform HashMap lookup of a tree until after checking more
cheaply if it refers to a symbol with by-name parameter type.
Avoid needless Name creation

 - Don't create names just to perform prefix/suffix checks
 - Don't create names, decode, *and* intern strings in ICode
Optimize implicit search

Avoid a full findMember in isImpossibleSubtype.
Instead, just see if any of of the base classes
has a non private decl with the given name.
Optimize tailcall elimination

From the "if a tree falls" department: don't bother create a finely
distinguished error messages about why the transform is inapplicable
if the current context doesn't demand it.
Don't try to eliminate tail calls in constructors.
Optimize the pickler phase

 - move "erroneous type" diagnostic into a crash recovery handler,
    rather than running it proactively
 - move the "unexpanded macros" check into refchecks.

 Cuts this phase in half, from about 1% of compile time to 0.5%.
Inlinability for Context#withMode

Finalize it explicitly, and make it effectively final as a backstop
by sealing Context.
Fix @inlinability of devWarning

It wasn't inlinable because it called a protected method, `isDeveloper`.
Disable overhead of dead code warnings outside of -Ywarn-dead-code
Optimization in TailCalls

Only store the position and reason for a failure to tailcall
transform a method if we ever need to report it, ie, if the
method was annotated with @tailrec.

Saves object hashing and map updates, profiling suggests
that this reduces the tailcalls phase from about 2% of compilation
time to about.

Also, clear the maps eagerly after each compilation unit,
rather than letting them accumulate entries for the entire
run. Working with smaller maps can't hurt.
Avoid work in GenICode#run when inactive.

scalaPrimitives.init() represented 1% of a small (1s)
compilation run.
Optimize generic signatures utility method `dotCleanup`
Optimize javaName in the backend

Avoid the reportedly expensive call to `exists` if the
old and new symbols are the same, which used to be
called as part of the assertion.

The profiler reported 1% in exists(), of which 63% comes
from javaName.

The next most frequent caller is `Context#isInPackageObject`.
I must confess, I still have trouble understanding what `exists` and
`reallyExists` actually mean.
Cache isDerivedValueClass in ClassSymbol
Optimize AnalyzerPlugins

  - exclude CPS plugin from the loop over plugins that still
    use deprecated hooks.
  - inline folds in hot paths

Time reported in `pluginsPt` and `pluginsTyped` dropped from
to 1000ms to 350ms in a 150s compile.
Optimize GenBCode: dealiasWiden rather than normalize
Dealias, rather than normalize in Uncurry's info transformer

And compensate in Erasure by flattening refined types before
synthesizing compound isInstanceOf checks.
Optimization in Pickler

Avoid creating an intermediate array.

The pickling phase takes about 2% of compilation; writeArray was
reporting 30% of this, and the call to take about 25% of that.

A microoptimization at best. But, life is a game of inches.
Optimize GenSeqLike.equals

Fast path if this and that are the same reference. This
is important in LazyTreeCopier; time spent in List.sameElements
drops from 1000ms to 440ms in a 150s compiler run.