REPL bells and whistles: -Dscala.repl.vids=<Boolean>

Displays identity hashcodes next to `res` values printed by REPL.
This proved quite useful in detecting reflection artifacts that look the same,
but are, in fact, different.
REPL bells and whistles: -Dscala.repl.maxprintstring=<Integer>

Makes `maxPrintString` configurable and fixes its treatment at zero.
Quite useful for debugging elaborate classloaders with long classpaths.
improves traces and error messages
macros: -Xmacros is now retired
macros: now use Java reflection

Due to some voodoo magic creating a new instance of a compiler cake,
immediately degrades performance of the compiler.

Out guess is that it makes HotSpot treat calls to cake methods as polymorphic.
However we didn't do any performance testing, it just works, and that's enough.
Enough for now.
macros: refactoring of fast track infrastructure

As a result, hardwired macros don't need implementation stubs.
This is very important, because in a few commits scala.reflect.makro.Context
will move out from scala-library.jar.

Also adding fast track entries doesn't require jumping through hoops
with PDTs. It's as simple as defining PartialFunction[Tree, Any].
preparations: removes DynamicProxy

This is necessary because toolboxes will no longer be available from the library.
Christopher Vogt will take care of the second reincarnation of DynamicRef.
preparations: always explicitly provide type tags

In our codebase we now explicitly provide type tags even if they can be materialized.
This is necessary to ease the upcoming reflection refactoring (or refactorings :)).
blob
ClassTag.erasure => ClassTag.runtimeClass

This change is made to be consistent with JavaMirrors.
And, in my opinion, a technology-neutral term is better here.
removes tags and their incantations from Predef

All tags and reflection-related stuff requires a prefix,
be it scala.reflect for simple tags (ArrayTags and ClassTags),
or scala.reflect.basis/scala.reflect.runtime.universe for type tags.
brings macros up to speed

Before reflection refactoring, macro contexts only exposed a mirror.
Now it's time to expose both a universe (the compiler instance) and
a mirror (a macro-specific symbol resolver).

By the way, speaking of mirrors. Macro contexts have their own mirror,
which is different from compiler's rootMirror. This is done because
macros need to be able to resolve stuff from empty package.

Reflection refactoring brought major changes to runtime evaluation,
which got dropped from universes and now requires scala-compiler.jar.
However there are macro users, who would like to do eval inside macros.
To help them we expose `libraryClassLoader` to manually build toolboxes,
and also a simple-to-use `c.eval` method.

I've also sneakily introduced `c.parse`, because it's something that
has also been frequently requested. Moreover, it might help Scaladoc.
So I decided that it might be worth it to add this new functionality.
brings reification up to speed

Along with recovering from reflection refactoring, I implemented
some new features (e.g. rollback of macro expansions),
and did some stabilizing refactorings (e.g. moved mutable state into a ghetto).

Also used the refactoring as a chance to fix free and aux symbols.
Encapsulated this notion in a symbol table class, which allowed me
to address outstanding issues with symbol table inheritance and inlining.
miscellaneous cleanup, mostly fighting with feature warnings
moves positions to scala.reflect.internal.util

This is the first step of factoring out scala-reflect.jar.
repairs the tests after the refactoring spree
Fixes SI-4909 and SI-5763

Finally, -sourcepath is split into:
-Ysourcepath     - for the library bootstrapping
-doc-source-path - for scaladoc links to source code

(squished the resident compiler test fix into this commit)

Review by @jsuereth.
Introduces scala-reflect.jar