Remove dependency on scala-xml.

Mimic https://github.com/scala/scala/commit/4e9b33ab24bb3bf922c37a05a79af364b7b32b84
Reorg of info transformer framework
Renamings TreeTransformer -> TreeMap, TreeMapper -> TreeTypeMap

This makes naming uniform between trees and types, and also avoids the clash with
transform.TreeTransformer. The idea is that transformers are parts of phases, and
have logic that is phase-specific. In particular, a context is passed around when
transforming a tree. Maps are simpler, they only have a T -> T apply method.
Renaming core.Transformer(s) -> core.DenotTransformer(s)

To bring in line with TreeTransformer terminology.
Refactored denotation transformers

Many small and large changes. Added samplePhase to demonstrate functionality.

To test functioning, run the compiler with args

     tests/pos/uncurry.scala -Ylog:sample,terminal
Re-enabled and renamed tests

CreateCompanionObjectTests were re-enabled. They failed in a previous version but succeed again in the latest commit.
Also uncurry.scala got renamed to curried.scala.
Merge pull request #79 from DarkDimius/noxml

Remove dependency on scala-xml.
LazyVals phase.

Creates accessors for lazy vals:
1) lazy local vals are rewritten to dotty.runtime.Lazy*** holders
2) for a non-volatile field lazy val create a non-thread-safe accessor and flag:
2.a) if lazy val type indicates that val is not nullable, uses null value as a flag
2.b) else uses boolean flag for sake of performance, method size, and
allowing more jvm optimizations
3) for a volatile field lazy val use double locking scheme, that guaranties no
spurious deadlocks, using long bits as bitmaps and creating companion
objects to store offsets needed for unsafe methods.

Conflicts:
	test/dotc/tests.scala
Allow MiniPhase to be DenotTransformer

All MiniPhases now as are full-fledged phases,
and are given their own periods and can register DenotTransformers.
MiniPhases belonging to same group(list) will be squashed to single phase.
apply srewrite (explicit types for implicits + no procedure syntax

for constructors) to tests/untried/pos
apply srewrite (no procedure syntax for constructors) to tests/untried/neg
move all tests in tests/untried/neg which use implicits to tests/untried/neg-with-implicits
Merge pull request #84 from samuelgruetter/srewrite-tests-1

Explicit types for implicits in tests/untried
Merge pull request #81 from DarkDimius/integration/lazy

 Allow MiniPhase to be DenotTransformer & LazyVals
Add language feature mechanism

Add a method "featureEnabled" that checks whether a feature is enabled. Features can be enabled
by imports or by command-line options. The Scala 2.10 way of enabling features by implicits got
dropped, because the use of the feature mechanism is now different.

Previously, features imposed restrictions on what used to work. So it was important to offer
way to avoid the restrictions it that was as smooth as possible, and implicits fit the bill.
Furthermore, features did not change the way things were compiled, so it was OK to test them
only once all types were compiled.

Now, features are essentially switches that change compile time behavior. keepUnions and
noAutoTupling, if on, will modify the way type inference works. So we need to interprete a
switch on the spot, and doing an implicit search to determine a switch value is too dangerous
in what concerns causing cyclic references. At the same time, because we are dealing with
new functionality, there is less of a concern for being able to set or reset features for large
pieces of code with some implicit. You could argue that's not even desirable, and that an
explicit import or command line option is preferable.

Conflicts:
	src/dotty/tools/dotc/core/SymDenotations.scala
Added auto-tupling.

Auto-tupling should satisfy the following spec.

1. An application `f(args)` where `f` is a non-overloaded method which has a single, non-repeated parameter as its
first parameter list and where args consists of two or more arguments is expanded to `f((args))`.

2. A constructor pattern `C(args)` where `C.unapply` is a non-overloaded method which has a single, non-repeated parameter as its first parameter list and where args consists of two or more arguments is expanded to `C((args))`.

Auto-tupling can be disabled by language feature "noAutoTupling".

Conflicts:
	test/dotc/tests.scala
Removed explicit tuplings from dotc codebase.

Eliminated all "Dotty deviations" which were due to lack of auto-tupling.
Allow And/OrTypes in baseType operations

Introduce new cases for AndTypes and OrTypes in methods `derivesFrom`, `baseClasses`, and `baseTypeWithArgs`.
These cases are ultimately needed so that `baseTypeWithArgs` makes sense for union and intersection types.

Also, fixed embarrassing typo in method `TypeBounds#|`.
Merge refined types when distributing via "|".

Use the equality (where ~ is any form of refinement)

  T1 { x ~ R1 } & T2 { x ~ R2 }  ==  T1 & T2 { x ~ R1 & R2 }

We already did the same thing when distributing via "&".
Appromiximate union types by intersections.

Appromiximate union types by intersections of their common base classes. Controlled by option -Xkeep-unions.
If option is set, no approximation is done.

Motivations for approximating: There are two. First, union types are departure from Scala 2. From time to
time they lead to failure of inference. One example experiences in Dotty was in a foldLeft, where the accumulator
type was inferred to be Tree before and was now a union of two tree specific kinds. Tree was the correct type, whereas
the union type was too specific. These failures are not common (in the Dotty codebase there were 3, I believe), but
they cause considerable difficulty to diagnose. So it seems safer to have a compatibility mode with Scala 2.
The second motivation is that union types can become large and unwieldy. A function like TreeCopier has a result
type consisting of ~ 40 alternatives, where the alternative type would be just Tree.

Once we gain more experience with union types, we might consider flipping the option, and making union types the
default. But for now it is safer this way, I believe.