Variance annotations printing

def printTypeParams is modified. Tests are updated.
val showOuterTests is removed

val showOuterTests wasn't used in Printers
Removes TODO comments that are no longer applicable

- we do not want to use mutable updates because that would mean making vals
vars, losing various guarantees for final fields of the java memory model

- we do not want to add more subcasses of HashSet, because that would make
callsites megamorphic. If anything, we should try to reduce the number of
subclasses

- checking for monomorphic call site is not worth it for a single virtual
method call.
toCode is added to Printers

1. Printers API is updated (def toCode)
2. ParsedTreePrinter is added to internal.Printers. ParsedTreePrinter generates the code for passed unattributed trees.
Generated code can be later compiled by scalac retaining the same meaning.
Tests for ParsedTreePrinter
Printers code refactoring and cleanup
Annotated trees processing is modified

1. Problem with multiple parameter lists in annotations is resolved
2. Tests for Annotated trees are added
Code cleanup based on pull request comments
toCode renamed to showCode
SI-8146 Pending test, diagnosis for bug in decidability of <:<
SI-8146 Test cases for typechecking decidability

Taken from "On Decidability of Nominal Subtyping with Variance"
(Pierce, Kennedy), which was implemented in 152563b.

Part of the implementation (SubTypePair) will be changed in the
following commit to fix the non-deterministic errors typechecking
heavily nested types involving aliases or annotations.
SI-8146 Fix non-deterministic <:< for deeply nested types

In the interests of keeping subtyping decidable [1], 152563b
added some bookkeeping to `isSubType` to detect cycles.

However, this was based on a hash set containing instances of
`SubTypePair`, and that class had inconsistencies between its
`hashCode` (in terms of `Type#hashCode`) and `equals`
(in terms of `=:=`).

This inconsistency can be seen in:

    scala> trait C { def apply: (Int @unchecked) }
    defined trait C

    scala> val intUnchecked = typeOf[C].decls.head.info.finalResultType
    intUnchecked: $r.intp.global.Type = Int @unchecked

    scala> val p1 = new SubTypePair(intUnchecked, intUnchecked)
    p1: $r.intp.global.SubTypePair = Int @unchecked <:<? Int @unchecked

    scala> val p2 = new SubTypePair(intUnchecked.withoutAnnotations, intUnchecked.withoutAnnotations)
    p2: $r.intp.global.SubTypePair = Int <:<? Int

    scala> p1 == p2
    res0: Boolean = true

    scala> p1.hashCode == p2.hashCode
    res1: Boolean = false

This commit switches to using `Type#==`, by way of the standard
case class equality.

The risk here is that you could find a subtyping computation that
progresses in such a manner that we don't detect the cycle. It would
need to produce an infinite stream of representations for types that
were `=:=` but not `==`. If that happened, we'd fail to terminate,
rather than judging the relationship as `false`.

[1] http://research.microsoft.com/pubs/64041/fool2007.pdf
Implements specialized subsetOf for HashSet

Fixes SI-7326. This also adds a basic test for subsetOf that was missing before.
Improved documentation of HashTrieSet internals

Added some more general documentation about how levels work and how the
bitmap field encodes the position of elems.
Merge pull request #3323 from rklaehn/topic/hashset-comment-cleanup-2

Removes TODO comments that are no longer applicable
Merge pull request #3363 from retronym/ticket/8146

 Fix non-deterministic <:< for deeply nested types
Merge pull request #3315 from rklaehn/issue/7326

Implements specialized subsetOf for HashSet
SI-8132 Fix false "overrides nothing" for case class protected param

Case class parameters that are less-than-public have an accessor
method created. In the enclosed test, we saw:

    case class G extends AnyRef with T with Product with Serializable {
      override <synthetic> <stable> <caseaccessor> def s$1: String = G.this.s;
      <caseaccessor> <paramaccessor> private[this] val s: String = _;
      override <stable> <accessor> <paramaccessor> protected def s: String = G.this.s;
      ...
    }

This commit removes the OVERRIDE flag from the accessor method,
which avoids the spurious "overrides nothing" error.
Merge pull request #3369 from retronym/ticket/8132

SI-8132 Fix false "overrides nothing" for case class protected param
Merge pull request #3321 from VladimirNik/sprinter

Add tree-based code generation