Fix cross talk between candidates in ImplicitComputation#findAll.

Haoyi reported that he couldn't get the presentation compiler
to offer completion suggestions for extension methods on primitive
arrays.

Turns out that an error in typechecking the previous candidate
had not been cleared, and this was taken to mean that `arrayIntOps`
was itself ineligible.

After this patch:
```
scala> Array(1, 2, 3) reverse
reverseIterator   reverse   reverseMap   reversed

scala> Array(1,2,3).reverse //print
   scala.Predef.intArrayOps(scala.Array.apply(1, 2, 3)).reverse

scala> Array(1, 2, 3) to
toString   toCollection   toSeq      toIterator   to              toMap      toSet          toList
toArray    toBuffer       toStream   toIterable   toTraversable   toVector   toIndexedSeq

scala> Array(1, 2, 3) toSeq
   override def toSeq: Seq[Int]
```

The classic banner is available under -Dscala.repl.power.banner=classic.

```
scala> :power
Power mode enabled. :phase is at typer.
import scala.tools.nsc._, intp.global._, definitions._
Try :help or completions for vals._ and power._
```

Transcript paste mode invites the user to keep typing like
regular paste mode, but really you must enter more transcript.

This matters if the script ends in the middle of incomplete
code that the user wants to complete by hand.

Previously,

```
scala> scala> def f() = {

// Detected repl transcript paste: ctrl-D to finish.

// Replaying 1 commands from transcript.

scala> def f() = {

scala> scala> def f() = {

// Detected repl transcript paste: ctrl-D to finish.

     | }
// Replaying 1 commands from transcript.

scala> def f() = {
}
f: ()Unit
```

Now,

```
scala> scala> def f() = {

// Detected repl transcript. Paste more, or ctrl-D to finish.

// Replaying 1 commands from transcript.

scala> def f() = {
     | 42
     | }
f: ()Int

scala> f()
res0: Int = 42
```

The presentation compiler currently demands that all interaction
is performed by asynchronous submission of work items, which are
queued and executed on the presentation compiler thread.

This is fairly inconvenient if you are a known-single-threaded client
that is trying to use the compiler from your own thread.

This commit adds an option to disable "assertCorrectThread" to better
support this use case.

Conveniences added:

  - The client need not determine ahead of time whether it wants
    scope completions of type member completions, this is inferred
    from the tree at the cursor
  - Computes the delta from the cursor to point where a suggested
    completion item should be written. This includes finding the
    position of the name within a Select node, which is tricky.
  - Includes a matcher that matches results base on prefix,
    accessibility and suitability in the syntactic location.
    Type members are not offered in term positions, and term members
    only offered in type position if they could for a prefix for
    a type. E.g. `type T = glob<TAB>` should offer `global` to help
    writing `global.Tree`.

In preparation for use of the presentation compiler to drive
REPL tab completion, add a dependency in the build.

As far as the outside world is concerned, these are already comingled
in scala-compiler.jar, and this patch doesn't change that.

val and var members of classes are split into getter/setter and field
symbols. However, we can't call `defString` on any of these and see
what existed in source code.

Example:

```
scala> class X { protected var x: Int = 0 }
defined class X

scala> val xField = typeOf[X].member(TermName("x "))
xField: $r.intp.global.Symbol = variable x

scala> xField.defString
res10: String = private[this] var x: Int

scala> xField.getterIn(xField.owner).defString
res11: String = protected def x: Int

scala> xField.setterIn(xField.owner).defString
res12: String = protected def x_=(x$1: Int): Unit
```

This commit introduces a new method on `Symbol` that pieces together
the information from these symbols to create an artificial symbol
that has the `defString` we're after:

```
scala> xField.sugaredSymbolOrSelf.defString
res14: String = protected var x: Int
```

The old implementation is still avaiable under a flag, but we'll
remove it in due course.

Design goal:

  - Push as much code in src/interactive as possible to enable reuse
    outside of the REPL
  - Don't entangle the REPL completion with JLine. The enclosed test
    case drives the REPL and autocompletion programatically.
  - Don't hard code UI choices, like how to render symbols or
    how to filter candidates.

When completion is requested, we wrap the entered code into the
same "interpreter wrapper" synthetic code as is done for regular
execution. We then start a throwaway instance of the presentation
compiler, which takes this as its one and only source file, and
has a classpath formed from the REPL's classpath and the REPL's
output directory (by default, this is in memory).

We can then typecheck the tree, and find the position in the synthetic
source corresponding to the cursor location. This is enough to use
the new completion APIs in the presentation compiler to prepare
a list of candidates.

We go to extra lengths to allow completion of partially typed
identifiers that appear to be keywords, e.g `global.def` should offer
`definitions`.

Two secret handshakes are included; move the the end of the line,
type `// print<TAB>` and you'll see the post-typer tree.
`// typeAt 4 6<TAB>` shows the type of the range position within
the buffer.

The enclosed unit test exercises most of the new functionality.

Move misplaced and malindented comment and remove two lines of unneeded code.

This makes life easier for clients of these APIs, we use this
to avoid passing this around in the wrapper result `TypeMembers`.

Trying harder to keep the synthetic interpretter wrapper classes
behind the curtain

This is just too useful to leave on the cutting room floor.

```
scala> classOf[String].enclo<TAB>

scala> classOf[String].getEnclosing
getEnclosingClass   getEnclosingConstructor   getEnclosingMethod

scala> classOf[String].simpl<TAB>

scala> classOf[String].getSimpleName

type X = global.TTWD<TAB>

scala> type X = global.TypeTreeWithDeferredRefCheck
```

I revised the API of `matchingResults` as it was clunky to reuse
the filtering on accessibility and term/type-ness while providing
a custom name matcher.