Temporary reversion of a bit of d8b96bb858.

If I reverse these few lines, I can rebase miguel's
pull request cleanly; if I don't, git thinks there are
enough merge conflicts to start a war. Something is
suboptimal in that algorithm.
warn about uninitialized reads (in constructors), self-contained check

The check in question relies on helper maps and methods that don't
belong outside that check. This commit encapsulates those helpers into
the newly added `checkUninitializedReads()` , thus uncluttering
`transformClassTemplate()`
handling AnyVal special case early on to simplify logic afterwards

This way the contract of `transformClassTemplate()` can focus on
non-AnyVal cases, which are more regular from the perspective of
transforming their templates in the constructors phase.
how stuff works: elision of param-accessor-fields and outer-accessors
eliding what the constructor phase elides but with less effort (1 of 2)

For now both old and new implementations of elision coexist,
allowing cross-checking their results.
In the next commit only the new one will remain.
eliding what the constructor phase elides but with less effort (2 of 2)

Removing the old implementation of elision in constructors
in favor of the new one which is both faster, more readable.
method transformClassTemplate() turned into class TemplateTransformer
separation of concerns: delayed-init in constructors
separation of concerns: elision in constructors
readability for intoConstructors transformer
separation of concerns: guard non-specialized ctor-stats in constructors
skipping trips to specializeTypes when not necessary in constructors
Reversing reversion of ac6504b8c4.

Putting back the bits I moved aside to get a clean rebase.
Golfed about 20 lines into the sand trap.

And it's a nice golf clinic and all, but let's remove our
golf gloves and take in some film.

  for (stat <- defBuf.iterator ++ auxConstructorBuf.iterator)

A quick count:

 - defBuf is a ListBuffer (1 mutant)
 - auxConstructorBuf is a ListBuffer (2 mutants)
 - two mutable iterators over mutable sequences (3, 4 mutants)
 - Iterator.++ joins them and is BY-NAME (4 mutants, 1 tragedy in waiting)
 - the joined Iterator is a new mutable structure (5 mutants, now 3 deep)
 - omittables is a mutable Set (6 mutants)
 - the 5-layer-3-deep iterator mutates omittables as it walks

[The following is a public service breakdown. The letter
sequence y-o-u is a local variable which should be replaced
with your name, whoever "you" are, if you commit any code in
these parts.]

Hear my plea! YOU DON'T HAVE TO DO IT THIS WAY! It isn't simpler,
faster, easier, more satisfying, shorter, more pixelated, there
just isn't any advantage to it, even if you're lazy! Especially
if you're lazy! Whatever combination of virtues and vices exist
in your personal petri dish, this will never be a hilltop!

PLEASE COME ENJOY A DRINK WITH ME AND MY FRIEND 'VAL' !!
I'LL INTRODUCE YOU! I THINK YOU WILL REALLY LIKE HER! I HOPE
YOU WILL SEE A LOT OF ONE ANOTHER! REMEMBER THAT NAME, 'VAL' !!
SHE'LL HAVE HER EYE OUT FOR YOU!
Add a TriState value class.

Sometimes true and false aren't enough.
New method typeRelationPreCheck.

Utilizes TriState from previous commit. Consolidates code
which had been duplicated across isSubType and isSameType.
Eliminated the shared logic.

Gave isSubType and isSameType a more closely parallel
structure to reduce both current and future duplication.
SI-7517 type constructors too eagerly normalized.

I think 403eadd0f1 was largely a symptomatic remedy
(not that we shouldn't harden against such outcomes)
and that this commit gets closer to the root causes.
The unanticipated change to test/files/run/t6113.check
is like a cry of support from the jury box.

  -Foo[[X](Int, X)]
  +Foo[AnyRef{type l[X] = (Int, X)}#l]

We should continue to look at calls to normalize with
grave suspicion.
SI-7520 bug in subtyping.

isSubType, if given two SingleTypes, would check =:= and
stop there. It is necessary to continue with weakening the left
hand side, because (for instance) the singleton type on the
left hand side could be a refinement class carrying parents
which are themselves single or constant types.
Merge pull request #2615 from paulp/issue/7517

SI-7517 type constructors too eagerly normalized.