Update some paths to relative
More statistics for created and retained trees
Performance improvement: Specialize folds in accumulators.
Performance improvements: Changes to TypeAccumulators and variances.
Discard inaccessible denotations when merging.

When froming the &=merge of two denotations, we now discard denotations which have inaccessible symbols.

The reason for this change is that, without it, the following code gives the warning "cannot merge Int and Int() as members of one type, keeping only Int()".

    val m = new java.util.HashMap
    m.size

Indeed java.util.HashMap has a filed and method which are both named size. The field is package private, so is inaccessible from outside java.util, however.
Performance improvement: Streamline successful toplevel subtype checks
Resetting uniques and hashset reorg.

Uniques are now cleared after each run. Also, HashSets get a more standard API, without a label, but with configurable load factor.
Avoid memory leaks on repeated compilation.

Several measures:

1. Invalidate classOfId and superIdOfClass in ContextBase after each run. These contain local classes
   that should become inaccessible.

2. Also clear implicitScope cache that maps types to their implicit scopes after each run. (not sure whether
   this is needed; it did show up in paths from root, but on second thought this might have been a gc-able
   cycle.

3. Avoid capturing contexts in lazy annotations.

4. Avoid capturing contexts in functions that compute souceModule and moduleClass

5. Avoid capturing contexts in Unpickler's postReadOp hook.
Misc performance improvements by eliminating stupid allocations

- Avoid closure creation in Position.
- Avoid creating debug string in SymDenotations
- Avoid creating Flag translation tables in pickle buffers
Performance improvement: Avoid most operations in interpolateUndetVars

Perform the operation only if there are qualifying type variables, which is rarely the case.
Reverted variances optimization to simpler and shorter previous implementation, because variances
is no longer hot.
Reord of superIds

1) We now keep an association between ClassSymbol and SuperId (instead of TypeRef and SuperId). That's better
   because superId's are deleted anyway after each run, so we gain nothing by keeping a stable ref.
2) hasChildren got dropped. It was too unreliable. The mere fact that someone take's the superId of a class
   does not means that that class has children.
Performance improvements: Split long TypeMap#mapOver and move hot fields into locals.
Performance tweak: Denotation.symbol is a parameter.

This avoids the megamorphic dispatch on symbol before. Looked promising in the profiler (symbol showed up at 9%) but does not seem to gain much in practice. Still, can't hurt to do it.
Performance improvement: Avoid unncecessary allocations of ListBuffer

There were a lot in StoreReporter, as we are creating about 0.5M new ones per self-compile.
Cleanup of isSubType
Drop task of simplifying hk types.

See examplation in 2nd commit of branch aborted/simplify-hk.
More precise untyped tree handling

1) Untyped trees now have precise isType/isTerm methods.
2) The New(tree, args) method can now also handle TypedSplices.
Reorganization of template parents.

Template parents always were constructor calls before. This is not correct because in a situation like the one
elaborated in templateParents, the trait D has the class C as supertype, but it does not call its constructor (in fact, if we added a () parameter list to make it into a constructor this would be wrong because C takes parameters.

Now parents can be either types or constructor calls.

The logic in Namer and Typer that deals with parents is cleaned up. In particular, we now construct any synthetic class parent as a full type, before calling normalizeToClassRefs. This obviates the forwardRefs logic that needed to be done in a cleanup of Namers.

Also added two more checks: (1) All parents except the first one must point to traits. (2) A trait may not call a parent class constructor.
Infrastructure for per-phase tests, with inline source as a string.
Fixing glb/lub of TypeBounds

Need to take variances into account when forming & or | of bounds. Achieved by moving code from distributeAnd/Or to TypeBounds &/|.