SI-8143 Regressions with override checks, private members

These regressed in e609f1f20b, which excluded all private methods from
overriding checks. We should only exclude private[this] members on the
low end of a pair, as was done before that commit, and, we must also
exclude private members on the high side.

Why? Warning: reverse engineered intuition follows.

We need to report an error when if a private method in a subclass
has matches a less-private method in the super class and report an
error, lest the user be fooled into thinking it might be invoked
virtually. On the other hand, adding a private method to a super
class shouldn't invalidate the choice names of public members in
its superclasses.

I've removed the test case added by that commit and will lodge a
reworked version of it that Paul provided as a new issue. That shows
a bug with qualified private + inheritance.

In addition, the expectation of `neg/accesses.check` is reverted
to its 2.10.3 version, which I believe is correct. When it was
changed in e609f1f20b it sprouted a variation, `neg/accesses-2`,
which has now changed behaviour. The intent of that test will
be captured in the aforementioned issue covering qualified private
inheritance.
Prohibit views targeting AnyVal

Library changes in Scala 2.10 mean that we are left with the
unfortunate situation of admitting:

    scala> "": AnyVal
    res0: AnyVal =

 We already have explicit checks in place to prevent views
 targeting `AnyRef`. This commit balances this out by prohibiting
 `AnyVal`, as well.

The enclosed test shows that this case is now prevented. If multiple
implicits views are applicable, the ambiguity error is still raised;
these check comes right at the end. Maybe that ought to be changed,
but I don't think it matters too much.

I've also disabled this prohibition under -Xsource:2.10.
SI-7322 Interpolator idents must be encoded

Otherwise, they are not found.

This matters for term names with a differential encoding.

Footnote, normally ident() encodes, but INTERPOLATIONID
is !isIdent, so that is not used here.  Maybe that would
be the better improvement.
SI-8213 AnyRefMap.getOrElseUpdate is faulty

Altered getOrElseUpdate to be robust to the map changing out from under it as a result of calling the default value method.  Side-effects FTW!

Made a comparable change in LongMap also, as it was also affected.  And added a test to SetMapConsistencyTest.
Merge pull request #3416 from retronym/topic/any-val-implicit

Prohibit views targeting AnyVal
Merge pull request #3434 from Ichoran/issue/8213

SI-8213 AnyRefMap.getOrElseUpdate is faulty
SI-7700 @unspecialized, Part Deux: Now Working.

This annotation was introduced to allow us to mark methods within
a specialized trait as immune from specialization. In particular,
this is desirable for `Function1.{andThen, compose}`.

However, it seems we need to check for this in two places in the
specialization code base. The feature is now backed with a test.
Merge pull request #3357 from retronym/ticket/8143

SI-8143 Regressions with override checks, private members
Avoid generic collections operations hot paths

 - Use a specialized version of List#{map, collectFirst}
   These special case mapping over an empty list and avoid
   allocating.
 - Avoid nonEmpty in favor of `ne Nil`

I see in the order of 2% speedup.

Perhaps more useful is that
these methods no longer dominate the YourKit profiles, even though
profiler bias due to safepoints at allocation of the ListBuffer
might have been overstating their significance.
Optimize isSelfSuperCall

Avoid the Applied extractor altogether, as that eagerly
creates `argss` which we don't need and which is quite
expensive.
Optimize TreeInfo#isMacroApplication.

It's called rather frequently. Tree#symbol is a megamorphic call,
which featured in profiles.
Typers#stabilize is a noop in erasure's typer.

Anything we can do to make erasure faster.
Optimize typedDefDef: disable some checks post typer

isPossibleRefinement reported as 1% of my profile, about half of that
was reported from the `EraserTyper`.

This commit restricts `checkMethodStructuralCompatible` to
the typer phase, and also moves in the feature warning for
implicits which was nearby.

I've also made a minor optimization to `overriddenSymbol` by
avoiding computing the method schema repeatedly.
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%.
Don't try to eliminate tail calls in constructors.
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.
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 1%.

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.
Merge pull request #3425 from retronym/ticket/7700

SI-7700 @unspecialized, Part Deux: Now Working.
SI-7124 make macro definitions prettier in scaladoc

Macros are now prettier in scaladoc, by
 - hiding the `macroImpl` annotation
 - showing the `macro` modifier in front
SI-7266 Stream leaks memory

Changed tail-generation function to mutable and clear it after it's used to allow any captured memory to be freed once the tail has been generated.

(This is a case where a by-name parameter was used when a lazy val parameter was wanted instead.  If we ever get lazy val parameters, we should switch to that.)