Implicits to encourage more Name-dropping.

This creates implicits in cakes across the land from:

  String => TermName
  String => TypeName

And also from:

  Name => NameOps[Name]           // lower priority
  TermName => NameOps[TermName]
  TypeName => NameOps[TypeName]

What this is all about, using "drop" as a motivating example,
is that these should all work:

  "abc" drop 1                      // "bc": String
  ("abc": TermName) drop 1          // "bc": TermName
  ("abc": TypeName) drop 1          // "bc": TypeName
  (("abc": TypeName): Name) drop 1  // "bc": Name

But this should not:

  ("bc": Name)  // ambiguity error

This requires drop not being directly on Name; peer implicits
from String => TermName and String => TypeName; implicit
classes to install drop on TermName and TypeName; and a lower
priority implicit class to allow ops on Names.

Review by @xeno.by .
Added a HIDDEN flag.

[Still not a fan of the massive overlap between GenJVM and GenASM. I do
not think such duplication should be allowed into master at all, neither
in experimental backends nor anywhere else. Putting us in the position
that we have to actually switch to stop incurring the duplication is
engineering-by-prayer.]

The SYNTHETIC flag was long ago discovered to be inadequately specific
to allow for emitting ACC_SYNTHETIC in bytecode. In this commit is born
a HIDDEN flag, which signals the flagged symbol as implementation detail
which should not be considered during typechecking, and which will
receive ACC_SYNTHETIC during code generation.

Unsure what should be hidden, I conservatively marked a few things which
seem safely hidable.

 - $outer fields and accessors
 - classes whose classfile has the jvm Synthetic attribute
   (not to be confused with the SYNTHETIC flag)

I leave additional choices to those who have a better idea how
this will materialize (i.e. IDE guys.)

It is easy to selectively introduce this flag; but the SYNTHETIC flag
is set or checked for in so many places, it is very difficult to alter
the logic around it (either by setting it less, or checking for HIDDEN
only) with much confidence. So right now HIDDEN is only used to help
ACC_SYNTHETIC make it into bytecode - it is only set in conjunction with
SYNTHETIC, and it doesn't help anyone hide from the typechecker.

Review by @dragos, @odersky.
SI-6052 - fix groupBy on parallel collections
Eliminated actors from partest.

The actors in partest were offering nothing but unnecessary
complication and an extra dependency.
Eliminated more logic.

Why hand out big blocks of tests to workers.  Just put them
all in a queue and let the threads consume them when they can.
This speeds up partest a fair bit in those not uncommon
situations where one worker would end up lagging well behind
the others, and drops another 150ish lines of code.

Test suite time on my 8-core machine goes from 28:21 to 22:34.
SI-6032 Enhance TaskSupport documentation.
SI-6022 model type-test-implication better

we use subtyping as a model for implication between instanceof tests
i.e., when S <:< T we assume x.isInstanceOf[S] implies x.isInstanceOf[T]
unfortunately this is not true in general.

SI-6022 expects instanceOfTpImplies(ProductClass.tpe, AnyRefClass.tpe), but
ProductClass.tpe <:< AnyRefClass.tpe does not hold because Product extends Any

however, if x.isInstanceOf[Product] holds, so does x.isInstanceOf[AnyRef],
and that's all we care about when modeling type tests
SI-6015 assertion (in Type-flow analysis) that wasn't, valid counterexample found
don't crash on syntactically incorrect value classes
statistics: print millis instead of micros.
polymorphic value classes

dropping boxing code, which turned out to be a dead end.
Merge commit 'refs/pull/851/head' into 2.10.x
Pickled flag reorg

Cleaned up and optimized code that maps between raw and pickled flags. Avoids mystery constants. Makes a whole bunch of new flags be pickled which were not pickled before (more precisely: Everything in InitialFlags with value greater than 1 << 31 which is not in FlagsNotPickled now gets pickled whereas before it wasn't. Among these: VARARGS, IMPLCLASS, SPECIALZED, DEFAULTINIT, SYNCHRONIZED. I am curious how many tickets will get fixed by this change.

The first one I noted is t5504, which previously enforced the buggy behavior through a neg check!

There are also some build manager check file changes that have to do with the fact that flags now print in a different order for performance reasons.
SI-6061 adds weakly conformance for number types to resolveOverloaded

This fix changes resolveOverloaded in scala.reflect.internal
so that numeric widening on the actual argument types is also
considered for primitive number types. Needs changes in functions
applicable and mostSpecific.
Bump version number for new nightlies.
starr sources to move cloneable class to package `annotation`
Moved cloneable class to package `scala.annotation`.

Requires a new starr.
SI-4763 Deprecated the `cloneable` annotation
Merge branch '2.10.x' into topic/pickledflags

Conflicts:
	src/reflect/scala/reflect/internal/Flags.scala
Removed EXISTENTIAL special case in unpickler.