an important fixup for macro universe API

It seems that this.type doesn't cut it for stuff declared in a trait.
Downgrading this.type to Symbol and Type correspondingly in
SymbolContextApi and TreeContextApi.
SI-5756 correctly reifies local module classes

Unlike module classes that are going to be pickled (which are reified
as `<their module reification>.moduleClass), module classes of
local modules need to be reified as symbol defs.

Otherwise we get a stack overflow:
1) Local modules are deemed to be free terms,
2) All free symbols are reified together with their type signature (so that they
   can be a) inspected by anyone interested, b) compiled at runtime),
3) Reifying a type signature of a module involves reifying its module class,
4) Reifying a module class involves reifying a module and calling its module class,
<ad infinitum>

This stack overflow doesn't happen for locatable modules, because they don't need
to have their type signatures reified (these signatures can later be loaded from
pickles if it becomes necessary).
SI-6204 reifier no longer causes cyclic errors

When reifying certain trees/types reifier might decide that it needs to
introduce auxiliary symbols to represent non-locatable components of types

For example, when reifying a refined type we need to reify the symbols
that correspond to its members (aka RefinedType.decls). Since these symbols
are not stored in pickles, we can't do the usual staticClass(scala.Int) stuff,
and are forced to actually create corresponding symbols inside the reificode
(by "create" I mean literally create, by using newXXXSymbol methods).

It looks like a generally good idea to not only create those symbols naked,
but to also export their type signatures and annotations. However this brings
problems with type inference.

Say, a type of a method A depends on a type tag. To get a type of a type tag,
the compiler needs to expand the corresponding macro (when the macro is being
expanded, symbol A is marked as LOCKED). While reification macro expands,
it might want to reify certain symbol definitions (as explained above). If one
of these definitions is a class that contains method A, we're in trouble,
since reifying the corresponding ClassInfoType will eventually call A.info,
which will produce a cyclic reference error, because A is LOCKED.

An obvious solution is to check whether a reified symbol definition is locked.
If the symbol is locked, then the reifier bails (e.g. by reifying NoType
instead of the actual type signature of the symbol).

Being obvious this solution is also incorrect as illustrated by SI-6204.
Sure we can check whether a symbol itself is locked, but we cannot check
whether or not we reify someone who refers to the locked symbol.

As of such I'm telling the reifier to bail whenever it needs to reify a symbol
definition for a symbol that is not yet complete. Therefore reification
can no longer cause inference of method result types, which eliminates the
underlying problem.

This is a harsh measure, but taking into account that we have an RC planned
within a week, stability trumps completeness.
Allow skipping the xz archives

Using 'ant -Darchives.skipxz=true'
accommodates reflection meeting feedback
Merge pull request #1099 from lrytz/no-xz

Allow skipping the xz archives
Merge pull request #1094 from scalamacros/ticket/6204

fixes to existential-related reification problems
Made inliner work for @inline methods that access private variables.

We need to disable the previous "potentiallyPublished" logic for this because that one disables inlining as long as the inlined method has a reference to a field with a $. But making fields public in @inline method will generate fields with $. We need to complement this with reverting the previous publication logic completely. I leave that to Vlad or Miguel.
Merge pull request #1104 from odersky/2.10.x

Made inliner work for @inline methods that access private variables.
SI-6022 refactor to clean up model of variable equality modulo <:

this commit does a functionality-preserving refactoring
SI-6022 cleaner model of variable equality modulo <:

a more conservative "excludes": no need to reason about types

(TODO: check we don't get any spurious unreachability errors
 in the eclipse build, which is a good canary for this kind of thing)
SI-6184 don't introduce dummies in checkableType

this should fix the crash in asSeenFrom that resulted from calling
baseTypeSeq on a type that had an unbound type parameter in it

also, simplify widenToClass
slightly smarter NNF
use isStable to decide to use ValueConst
SI-6146

- must widen prefix to get a type that encompasses type tests with varying instances for the outer classes
- align prefixes for validity check

we're on the right track, but need to deal with varying prefixes of the types of value consts now:

[scalacfork] /Users/adriaan/git/scala-build/src/library/scala/util/parsing/combinator/PackratParsers.scala:216: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: Error(_, _), Failure(_, _), Success(_, _)
[scalacfork]         seed match {
[scalacfork]         ^
[scalacfork] /Users/adriaan/git/scala-build/src/library/scala/util/parsing/combinator/lexical/Scanners.scala:49: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: Error(_, _), Failure(_, _), Success(_, _)
[scalacfork]         token(in1) match {
[scalacfork]              ^
[scalacfork] /Users/adriaan/git/scala-build/src/library/scala/util/parsing/combinator/lexical/Scanners.scala:47: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: Error(_, _), Failure(_, _), Success(_, _)
[scalacfork]     private val (tok, rest1, rest2) = whitespace(in) match {
[scalacfork]                                                 ^
[scalacfork] /Users/adriaan/git/scala-build/src/reflect/scala/reflect/internal/Symbols.scala:70: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: TermName_R(), TermName_S(), TypeName_R(), TypeName_S()
[scalacfork]     def newNestedSymbol(name: Name, pos: Position, newFlags: Long, isClass: Boolean): Symbol = name match {
[scalacfork]                                                                                                ^
[scalacfork] /Users/adriaan/git/scala-build/src/reflect/scala/reflect/internal/Symbols.scala:390: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: TermName_R(), TermName_S(), TypeName_R(), TypeName_S()
[scalacfork]     final def newErrorSymbol(name: Name): Symbol = name match {
[scalacfork]                                                    ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/reflect/macros/runtime/Typers.scala:22: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: SilentResultValue(_), SilentTypeError(_)
[scalacfork]     wrapper(callsiteTyper.silent(_.typed(tree, universe.analyzer.EXPRmode, pt)) match {
[scalacfork]                                 ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/reflect/reify/codegen/GenTypes.scala:129: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: SilentResultValue(_), SilentTypeError(_)
[scalacfork]     result match {
[scalacfork]     ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/cmd/gen/AnyVals.scala:31: warning: unreachable code
[scalacfork]         case S | C => companionCoercions(I, L, F, D)
[scalacfork]                                         ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/cmd/gen/AnyVals.scala:214: warning: unreachable code
[scalacfork]       case C => "java.lang.Character"
[scalacfork]                 ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/cmd/gen/AnyVals.scala:220: warning: unreachable code
[scalacfork]       case F => "0.0f"
[scalacfork]                 ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala:1280: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: ARRAY(_), BOXED(_), BYTE, REFERENCE(_), SHORT, TypeKind(), UNIT
[scalacfork]     def getZeroOf(k: TypeKind): Instruction = k match {
[scalacfork]                                               ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala:323: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: Dynamic, Static(_), SuperCall(_)
[scalacfork]         case CALL_METHOD(method, style) => style match {
[scalacfork]                                            ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala:1531: warning: unreachable code
[scalacfork]                   case (NE, Failure) => jcode emitIFNONNULL labels(success)
[scalacfork]                                               ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala:1547: warning: unreachable code
[scalacfork]         case NE => mcode.Emit(OpCodes.Bne_Un, dest)
[scalacfork]                              ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala:1545: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: EQ, GE, GT, LE, LT, NE
[scalacfork]       condition match {
[scalacfork]       ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/doc/model/ModelFactoryImplicitSupport.scala:181: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: SilentResultValue(_), SilentTypeError(_)
[scalacfork]           newTyper.silent(_.typed(appliedTree, global.analyzer.EXPRmode, WildcardType), false) match {
[scalacfork]                          ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/typechecker/Implicits.scala:224: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: TermName_R(), TermName_S(), TypeName_R(), TypeName_S()
[scalacfork]     name match {
[scalacfork]     ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/typechecker/Macros.scala:411: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: SilentResultValue(false), SilentResultValue(true)
[scalacfork]               boundsOk match {
[scalacfork]               ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/nsc/typechecker/Typers.scala:3946: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: TermName_R(), TermName_S(), TypeName_R(), TypeName_S()
[scalacfork]         name match {
[scalacfork]         ^
[scalacfork] /Users/adriaan/git/scala-build/src/compiler/scala/tools/reflect/ToolBoxFactory.scala:148: warning: match may not be exhaustive.
[scalacfork] It would fail on the following inputs: SilentResultValue(_), SilentTypeError(_)
[scalacfork]             currentTyper.silent(_.typed(expr, analyzer.EXPRmode, pt)) match {
[scalacfork]                                ^