SI-7776 post-erasure signature clashes are now macro-aware

"double definition: macro this and method that have same type after erasure"
This error doesn't make sense when macros are involved, because macros
expand at compile-time, where we're not affected by erasure. Moreover,
macros produce no bytecode, which means that we're safe from VerifyErrors.
Enforce consistency of pack, docs, osgi, maven tasks.

Instead of scattering properties all over invocations of
staged-docs, staged-pack, make-bundle, copy-bundle and mvn-package,
these are now all fully determined by the project they act on.

The varying arguments to these macros are all centralized.
They are named like `project.prop`, where `prop` is one of:
description, package, dir, name, namesuffix, version,
targetdir, targetjar, jar, docroot, skipPackage, srcdir, src, srcjar.

The defaults for these properties are computed using `init-project-prop`.
De-duplicate logic in maven deployment.
Render relevant properties to buildcharacter.properties
Extra repository hook via `extra.repo.url` var

Previously defaulted to 'https://oss.sonatype.org/content/repositories/releases',
now must be set manually. PR validation uses it to configure the repository
that has the artifacts published during validation.
More useful ant targets for faster pr validation
IDE needs actors/swing/continuations publish for validation.

As soon as they are also modularized, we can go back to
only building/publishing the core (lib/reflect/compiler).
Fast path for ByNameClass in isImpossibleSubtype

These show up often due to the way that searches for
implicit views operate: firstly `A=>B` is sought, and
failing that `(=>A) => B`.
Cache ImplicitInfo#isCyclicOrErroneous

An optimization in implicit search.

ImplicitInfo-s themselves are cached (per-run) in Contexts
(for in-scope implicits) and in Implicits (for companion object
implicits.)
Add a per-run cache for member symbols

We are all used to calls to `definitions.PredefModule`, or
`defintions.Predef_???` to grab the symbol of some well known
entity. But you'll notice that some of these are lazy vals,
and others are defs.

Why is this so? In the presentation compiler, a member like
`Predef.???` will be assigned a new symbol after the user
browses into `Predef.scala`.

Mistakenly using vals in definitions leads to subtle
IDE bugs like SI-7678. We are able to trigger these
situations in tests, as noted in the comments of that issue.

Changing the vals to defs, on the other hand, has a performance
penalty. Some schemes to workaround this have shown up:
cache them per-implicit search, or compare method names and owners
rather than symbols on hot paths in the type checker.

This commit introduces a facility to cache these sort of symbols
per-run, and uses it to check for `Predef.conforms` and
and for the class/type tag materializers.

A followup pull request (WIP: https://github.com/retronym/scala/compare/ticket/7678-2)
will expand the use of to address the widespread and unsafe caching
of member symbols that I found while investigating SI-7678.
SI-7678 Don't cache member symbols of TypeTags in Definitions.

It we can only safely use vals in Definitions for top-level symbols.
Otherwise, when the IDE switches to loading the symbol from source,
we can hold on to a stale symbol, which in turn impedes implicit
materialization of TypeTags.

This commit moves (most) of the accessors for member symbols
into RunDefinitions, and changes calling code accordingly.
This is a win for presentation compiler correctness, and
might even shave of a few cycles.

In a few cases, I have had to leave a `def` to a member symbol
in Definitions so we can get to it from the SymbolTable cake,
which doesn't see RunDefinitions.

The macro FastTrack facility now correctly recreates the mapping
from Symbol to macro implementation each run, using a new facility
in perRunCaches to create a run-indexed cache.

The enclosed test recreates the situation reported in the ticket,
in which TypeTags.scala is loaded from source.
Merge pull request #3101 from xeno-by/ticket/7776

SI-7776 post-erasure signature clashes are now macro-aware
Merge pull request #3092 from retronym/ticket/7678-2

Small implicit optimizations, and SI-7678 RunDefinitions
Avoid needless TypeRef allocation during erasure.

  - ThisType(some.package) need not be erased, we can let
    that prefix through unchanged and avoid churning through
    allocations.
  - Sharpen the condition in `rebindInnerClass`. The answer
    to the deleted comment in the code, is "anonymous and
    local classes", which are specifically excluded in the
    new formulation.
  - Finally, detect if erasure of the TypeRef is an identity and reuse
    the original.

Waste not, want not.

To expand on the first point, here is what used to happen during
erasure:

    scala> val scalaPack = typeOf[Predef.type].prefix
    scalaPack: $r.intp.global.Type = scala.type

    scala> typeDeconstruct.show(scalaPack)
    res19: String = ThisType(package scala)

    scala> typeDeconstruct.show(erasure.scalaErasure(scalaPack))
    res20: String = TypeRef(TypeSymbol(final class scala extends ))

Showing one step of the erasure type map:

    scala> typeDeconstruct.show(scalaPack.asInstanceOf[SubType].underlying.typeOfThis)
    res21: String = SingleType(pre = ThisType(package <root>), package scala)
Address review comments

  - anonymize unused pattern binder
  - avoid negations
Merge pull request #3103 from Ichoran/topic/tidy-collections

Topic/tidy collections
A value class for Precedence.

One fewer Int to be whizzing around the parser hoping to
be confused with other Ints.
Rewrites the parser stack reduction logic.

Centralizes the scattered logic surrounding erroneous
pattern syntax. Consolidates the redundant lookahead
implementations. Eliminates var manipulation in favor
of recursion.
Parser stack reduction discussion

Check files
Parser stack reduction peekingAhead

Restores a form of the previous peekAhead bookkeeping.

Instead of tracking the current token and offset outside
of xxxAhead, peekingAhead uses `in.prev` and will push
back if the operation results in an empty tree.