SI-6419 Repl save session command

A simple save command to write out the current replay stack.

```
scala> val i = 7
i: Int = 7

scala> val j=  8
j: Int = 8

scala> i * j
res0: Int = 56

scala> :save multy.script

scala> :q
apm@mara:~/tmp$ cat multy.script
val i = 7
val j=  8
i * j
apm@mara:~/tmp$ skala
Welcome to Scala version 2.11.0-20130626-204845-a83ca5bdf7 (OpenJDK 64-Bit Server VM, Java 1.7.0_21).
Type in expressions to have them evaluated.
Type :help for more information.

scala> :load multy.script
Loading multy.script...
i: Int = 7
j: Int = 8
res0: Int = 56

scala> :load multy.script
Loading multy.script...
i: Int = 7
j: Int = 8
res1: Int = 56
```
SI-4594 Enable mutating mutable multi settings

Previously, multi-valued settings (String- and Phase- valued) could be
augmented but not cleared.  Also, phase settings included lazily cached
values that were not recomputed when the setting was changed.
SI-4594 Repl settings command

A settings command for the rest of us.

The usual command line options are used, except that boolean flags
are enabled with +flag and disabled with -flag.

```
scala> :settings +deprecation

scala> new BigInt(java.math.BigInteger.TEN) { }
<console>:8: warning: inheritance from class BigInt in package math is deprecated: This class will me made final.
              new BigInt(java.math.BigInteger.TEN) { }
                  ^
res0: BigInt = 10

scala> :settings -deprecation

scala> new BigInt(java.math.BigInteger.TEN) { }
res1: BigInt = 10
```
Multivalue "colon" options can be reset by supplying no values
after the colon.  This behavior is different from the command line.

```
scala> 1 toString
warning: there were 1 feature warning(s); re-run with -feature for details
res0: String = 1

scala> :settings -language:postfixOps

scala> 1 toString
res1: String = 1

scala> :settings
-d = .
-encoding = UTF-8
-explaintypes = false
-language = List(postfixOps)
-nowarn = false

scala> :settings -language:

scala> :settings
-d = .
-encoding = UTF-8
-explaintypes = false
-language = List()
-nowarn = false
```
SI-7637 Repl edit command

Open an editor with historical text.

:edit id will use the complete text of the defining line, including
a multiline expression or template definition.  The id must be a term
or type in scope, in particular, defined in the current session.

:edit line will use the specified line(s) from history, as a line
number (123), range (123-130), offset (123+7), remaining (123-) or
previous (-10 for last ten lines).

The env var EDITOR is used to specify an editor to invoke.

If EDITOR is not set or if :line command is used, the selected text
is added to the end of history.

Text is still added to history one line at a time (cf SI-1067).
No more duplication in maven-deploy.xml.

I just couldn't stand the incredible mess in there anymore. More cleanup to come.
For now, suffice it to say you need only add one line per new module.
Spin off src/library/scala/xml to src/xml/scala/xml.

Summary:
  - Remove the last vestiges of xml from Predef and Contexts.
  - Change build to compile scala.xml to scala-xml.jar.
  - Deploy scala-xml module to maven.
  - Update partest accordingly.

Note:
An older compiler cannot use the new standard library to
compile projects that use XML. Thus, skipping locker will
break the build until we use 2.11.0-M4 for STARR.

In the future build process, where we drop locker,
we would have to release a milestone that supports the old
and the new approach to xml. As soon as we'd be using that
new milestone for starr, we could drop support for the old approach.
Spin off parser combinators to scala-parser-combinators.jar.
Unfork jline: use vanilla jline 2.11 as a dependency.

Notes:
  - no longer specifying terminal by class name in scripts (using 'unix')
  - jline doesn't need a separate jansi dependency;
    it includes its own version according to:
    http://mvnrepository.com/artifact/jline/jline/2.11
Add meta-information for dbuild.

The next version of [dbuild](http://typesafehub.github.io/distributed-build/0.5.3/index.html)
will parse `dbuild-meta.json` to determine which jars are produced by a Scala build.

This way we can modularize without changing dbuild itself.

Yes, I know `dbuild-meta.json` should be generated during the build.
However, given the state of our build.xml, I think this is pointless.

My goal is to generate build.xml, dbuild-meta.json and Eclipse projects
from a higher-level description of our build. Baby steps...

Including improvements by @cunei:
  - Removing outdated field "uri" from ExtractedBuildMeta
  - Changed "partest" to "scala-partest" (the actual jar name)
Updated eclipse project files.

Set everything up so that soon-to-be independent modules are
compiled with the Eclipse plugin's compiler & library (2.11.0-M3 currently).

Most projects still compile with 2.11.0-M3, but
partest will need a nightly build of 2.11.
Fix docs inconsistent (cmp -> ord).

The parameter name is 'ord', but mentioned in docs with 'cmp'.
SI-7638 Superaccessor lookup after specialization

The crash was caused by a symbol lookup to rewire the super calls,
done after pickler, but specialization added new traits and new
members, thus making the super rewiring impossible. To avoid such
problems, this patch moves symbol lookup after specialization,
so the changes done by specialization (and miniboxing) become
visible to mixin.

Review by @adriaanm or @retronym.
moves TreeBuilder into the parser

This is the first of the two patches to the parser necessary for
quasiquotes to function.

This one moves TreeBuilder from Global to the internals of the Parsers,
so that quasiquotes will be able to override it later to support some
corner cases arising from splicing (see the subsequent quasiquote commit
for more details).

Surprisingly enough, almost noone used TreeBuilder outside the parser,
and it was necessary to move just a couple of methods to TreeGen to
satisfy broken dependencies.
extensibility hooks for parser

This is the second of the two patches to the parser necessary for
quasiquotes to function.

This one applies just a couple of minor changes to the way parser works,
so that quasiquotes will be able to extend it to support some
corner cases arising from splicing (see the subsequent quasiquote commit
for more details).
adds the lookahead routine to the parser

Introduces a scoping operator used to temporarily look into the future.
Backs up scanner data before evaluating a block and restores it after.

Not used anywhere, only necessary for the upcoming quasiquote patch
in order to reliably detect and accordingly process holes in quasiquoted
Scala syntax.
moves template creation logic from nsc to reflect

This routine is going to be necessary in scala-reflect.jar to support
ClassDef construction/deconstruction in the upcoming quasiquote patch.
introduces extensibility hooks into the reifier

Quasiquoting macros are surprisingly similar to reifying macros, since
both take something and then produce Scala ASTs for that something.

Therefore the upcoming quasiquote patch reuses the vanilla reifier,
adjusting it in key points to enable splicing and extraction to
support string interpolation syntax.

In this commit we prepare the reifier for being reused later on,
adding a modest amound of extensibility hooks.
implements quasiquotes

- Additions to the reflection API:

  - The Quasiquotes implicit class that defines `q`, `tq`, `pq` and `cq`
    interpolators which now become a part of the `scala.reflect.api.
    Universe`.

  - Implementations of the interpolators are macro-based
    and are hardwired through `FastTrack`.

  - The `Liftable` class and the `StandardLiftables` slice of the cake
    that provide a type class and a bunch of its instances that allow
    to easily splice user-defined types into quasiquotes.

  - Additional methods in `BuildUtils` that are used by the quasiquote
    macro to generate trees, notably:

    - `SyntacticClassDef`. An extractor/constructor that allows to
      construct and deconstruct classes using arguments that mirror
      syntactic form of ClassDefs (e.g. constructor outside of the
      body).

    - `TupleN`, `TupleTypeN`. Extractor/constructor for easy
      construction of ast that represents a tuple term or type
      with given amount of elements.

- Actual implementation of quasiquotes in the `scala.tools.reflect.
  quasiquotes` package which is organized into a cake called
  `Quasiquotes` with slices introducing core abstractions necessary to
  splice into Scala syntax, routines for interfacing with the parser,
  and customized reifiers for tree construction and deconstruction.
introduces unapply macros for internal use

Adds a macro hook into the unapply part of `doTypedApply`, provides
`macroExpandUnapply` in the macro engine and applies a couple of minor
refactorings along the way (renames the ugly `macroExpand1` into
oblivion, changes the ctor of `Fingerprint` to be private and upgrades
`MacroRole` from a string to a value class).

Unapply macros haven't been approved for inclusion in 2.11.0, however
they are necessary for pattern-matching quasiquotes. Therefore I'm only
allowing them to expand for QuasiquoteClass_api_unapply.
tests for quasiquotes

Introduces an extensive ScalaCheck-based test suite for recently
implemented quasiquotes. Provides tools for syntactic tree comparison
and verifying compilation error messages.