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).
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 #3094 from retronym/topic/erasure-opt

Avoid needless TypeRef allocation during erasure.
Merge pull request #3108 from adriaanm/faster-build

Faster PR validation
Merge pull request #3100 from som-snytt/paulp/reduction

Paulper stack reduction
REPL has smart imports

Predef imports are sorted to the top of the compilation unit.
Only the last import Predef from history is used.

```
scala> class X { override def toString = "MyX" }
defined class X

scala> val x = new X
x: X = MyX

scala> x + "a"
res0: String = MyXa

scala> println(5)
5

scala> import Predef.{ any2stringadd => _, StringAdd => _, _ }
import Predef.{any2stringadd=>_, StringAdd=>_, _}

scala> x + "a"
<console>:15: error: value + is not a member of X
              x + "a"
                ^

scala> import Predef.{ println => _, _ }
import Predef.{println=>_, _}

scala> println(5)
<console>:13: error: not found: value println
              println(5)
              ^

scala>  x + "a"
res4: String = MyXa

scala> import Predef._
import Predef._

scala> println(5)
5

scala>  x + "a"
res6: String = MyXa
```

The `imports` command has the ability to manage a list of quarantined names.

`:imports goo` queries for imports of `goo`, and `:imports -goo` puts `goo`
into quarantine.

```
scala> object Foo { def goo = 9 }
defined object Foo

scala> import Foo.goo
import Foo.goo

scala> goo
res7: Int = 9

scala> :impo
 1) import Predef.{any2stringadd=>_, StringAdd=>_, _} (126 terms, 62 are implicit)
 2) import Predef.{println=>_, _}  (126 terms, 62 are implicit)
 3) import Predef._                (126 terms, 62 are implicit)
 4) import Foo.goo                 (1 terms)

scala> :impo -goo
 1) import Predef.{any2stringadd=>_, StringAdd=>_, _} (126 terms, 62 are implicit)
 2) import Predef.{println=>_, _}  (126 terms, 62 are implicit)
 3) import Predef._                (126 terms, 62 are implicit)
 4) import Foo.goo                 (1 terms) // imports: (goo)

scala> goo
<console>:14: error: not found: value goo
              goo
              ^
```

The notation `(goo)` means that the import of `goo` is suppressed.
SI-7747 Scripter phase does script packaging

Refactors script wrapper generation from the parser to
a subsequent transform, with the goal of enabling custom
script wrapping by a plugin phase.

The parser simply wraps script trees in the special
`<script>` package, which is immediately unwrapped by
the scripter phase.

Since tailcalls is already effectively disabled by
`-g:notailcalls`, let it opt out of phase assembly.
SI-7747 Phases are subject to replacement

The plugins loader no longer screens for duplicate phase names.

When a component is added to the set of phases, the old phase
with the same name is removed first.

The test demonstrates replacing the scripter phase.
add replater phase
SI-1945 Local refactor for readability
SI-1945 REPL accretes lines to fix syntax

On a syntax error, if the last line compiled without
error, REPL will concatenate the two lines and try to
compile the result.

The use case is splitting an if/else over two lines
of input.

REPL will not retry on typer errors: that feature
would allow the use case currently handled by looking
for leading dot. For example, "abc"\nlength would work
as postfix invocation.

It does assist dot-completion in the case of extra
whitespace: "abc"\n .length works by accretion.
SI-7747 Replater

Refactor javax.script. $eval gen in collector.

Refactor startup so compiler stays on main thread.

Add splash loop to handle user input on startup.
Reporter fixes, tests, empties

error flushing

fix Global stop after parser