SI-8027 REPL double tab regression

Where did double tab go?  "The shadow knows."

The regression was introduced by the last flurry
before we were left to wallow in whatever white
space remained.

Some xs put other xs under erasure.

It's clear that somebody's daughter walked into
the room and asked for a story, because, shockingly,
the case arrows don't line up.

We need a plug-in for Jenkins, or I guess Travis, to
fail the build if arrows and equals don't align,
because it clearly indicates a lapse of some kind.
SI-4841 Plugins get a class path

Let -Xplugin specify a class path (or multiple of them).

Each entry can be a jar or dir, and the first entry to supply
a plugin descriptor defines the plugin to load.

If no plugin is found on the path, then issue a warning if `-Xdev`.
This honors the legacy silent treatment (which scala-ide tests for).

In the proposed scheme, each plugin gets a class loader so that
plugins are isolated from each other.

Presumably, if compiler plugins were a rich ecosystem, in which
shared dependencies were required in incompatible versions, this
would have become a requirement by now.

(Updated with a `DirectTest` that uses two plugins, but keeping
the following as documentation.)

Partest can't do multiple plugins yet, but this is what it looks like:

```
skalac -Xplugin:sample.jar:useful.jar:util,needful.jar:another.jar:util,needful.jar:util:exploded -Xplugin-require:sample,another,other foo.scala

skalac -Xplugin:sample.jar:useful.jar:util,needful.jar:another.jar:util,needful.jar:util:exploded -Xplugin-require:sample,other -Xplugin-disable:another foo.scala

skalac -Xplugin:sample.jar:useful.jar:util,sample.jar:useful.jar:util -Xplugin-require:sample foo.scala
```
The manual test shows three plugins with various permutations of jars and dirs.

The manual test demonstrates that plugins only see classes on their class path:

```
Initializing test.plugins.SamplePlugin
needful.Needful? Failure(java.lang.ClassNotFoundException: needful.Needful)
useful.Useful? Success(class useful.Useful)
Initializing more.plugins.AnotherPlugin
needful.Needful? Success(class needful.Needful)
useful.Useful? Failure(java.lang.ClassNotFoundException: useful.Useful)
Initializing other.plugins.OtherPlugin
```

Disabling a plugin results in a message instead of silent suppression:

```
Disabling plugin another
```

The duplicate plugin class test must still be honored:

```
Ignoring duplicate plugin sample (test.plugins.SamplePlugin)
Initializing test.plugins.SamplePlugin
needful.Needful? Failure(java.lang.ClassNotFoundException: needful.Needful)
useful.Useful? Success(class useful.Useful)
```

If the path is bad, then missing classes will report which plugin induced
the error:

```
Error: class not found: util/Probe required by test.plugins.SamplePlugin
Error: class not found: util/Probe required by more.plugins.AnotherPlugin
Initializing other.plugins.OtherPlugin
needful.Needful? Success(class needful.Needful)
useful.Useful? Failure(java.lang.ClassNotFoundException: useful.Useful)
error: Missing required plugin: sample
error: Missing required plugin: another
two errors found
```
SI-8054 Fix regression in TypeRef rebind with val overriding object

Regressed in 80767383fd / SI-7928

The condition added in that commit are necessary after refchecks but
poisonous before.

This still seems rather fragile: I wonder if `eliminateModuleDefs`
in `RefChecks` ought to flag the module symbol as `ARTIFACT` after
creating the accessor, so as to signal that it shouldn't be bound
anymore?
SI-8008 Make q”f(..$xs)” only match trees with Apply node

Previously it also matched other nodes but returned Nil as value of xs.
This behavior was added for sake of consistentcy with q”f[..$ts]”. On
the other hand q”f[..$Nil]” == q”f” but q”f(..$Nil)” == q”f()” not q”f”.
Due to this deconstruction/construction symmetry was broken.

On the other hand applications also have q"f(...$xss)" option which is
infact similar to q"f[..$ts]". Splicing Nil into it also results in q"f".
SI-8016 Ensure that q”..$xs” is equivalent to q”{..$xs}”
SI-8009 Ensure that Idents preserve isBackquoted property
SI-6842 Make splicing less sensitive to precise types of trees

Previously trees that represent parameters, case clauses and
type variables had strictly defined ValDef, TypeDef and CaseDef
types which caused problems in compositionality.

Now this checks are moved to runtime so it's possible to pass
a tree that is CaseDef but has Tree type.
SI-7979 Fix quasiquotes crash on mismatch between fields and constructor
Move Liftable into the Universe cake; add additional standard Liftables

Previously we believed that having Liftable outside of the Universe will
bring some advantages but it turned out this wasn’t worth it. Due to
infectious nature of path dependent types inside of the universe one
had to cast a lot. A nice example of what I’m talking about is a change
in trait ArbitraryTreesAndNames.

Additionally a number of standard Liftables is added for types that are
available through Predef and/or default scala._ import: Array, Vector,
List, Map, Set, Option, Either, TupleN.
Provide a way for unapply macro to obtain a list of subpattens

This commit introduces internal attachment that allows unapply macros to
be aware of their sub patterns and tweak their expansion depending
on that info.

At the moment this is not possible due to the way pattern macros are
expanded:

	case MacroPat(inner1, inner2) => ...

During type checking this will expand as

	MacroPat.unapply(<unapply-dummy>)

Meaning that macro can’t see inner1 and inner2 in it’s macroApplication.
To circumvent this we attach that info as an attachment to the dummy.
Refactor Holes and Reifiers slices of Quasiquotes cake

This commit performs a number of preliminary refactoring needed to
implement unliftable:

1. Replace previous inheritance-heavy implementation of Holes with
   similar but much simpler one. Holes are now split into two different
   categories: ApplyHole and UnapplyHole which correspondingly represent
   information about holes in construction and deconstruction quasiquotes.

2. Make Placeholders extract holes rather than their field values. This
   is required to be able to get additional mode-specific information
   from holes (e.g. only ApplyHoles have types).

3. Bring ApplyReifier & UnapplyReifier even closer to the future where
   there is just a single base Reifier with mode parameter.

Along the way a few bugs were fixed:

1. SI-7980 SI-7996 fail with nice error on bottom types splices

2. Use asSeenFrom instead of typeArguments in parseCardinality.
   This fixes a crash if T <:< Iterable[Tree] but does not itself
   have any type arguments.

3. Fix spurious error message on splicing of Lists through Liftable[List[T]]
Introduce support for Unliftable for Quasiquotes

Unliftable is a type class similar to existing Liftable that lets
users to extract custom data types out of trees with the help of
straightforward type ascription syntax:

  val q“foo.bar(${baz: Baz})” = ...

This will use Unliftable[Baz] to extract custom data type Baz out of
a tree nested inside of the another tree. A simpler example would be
extracting of constant values:

  val q”${x: Int} + ${y: Int}” = q”1 + 2”
SI-7789 make quasiquotes deconstruct UnApply trees
Test tuple lifting and unlifting
Test unliftable not found scenario
Test usage of SubpatternsAttachment from a macro
Test possible quasiquote runtime failures
Address minor pull request feedback points

1. Use (x1, x2): (T1, T2) instead of (x1: T1, x2: T2)

2. More detailed error message for improper function argument

3. Fix typo

4. Completely remove LiftableClass symbol from definitions
Merge pull request #3255 from densh/pr/unliftable-3

Introduce Unliftable for Quasiquotes (take #3)
Merge pull request #3241 from retronym/ticket/8054

SI-8054 Fix regression in TypeRef rebind with val overriding object