Reduce visibility of implicit type tags.

500 lines of generated boilerplate is *impossible to maintain*.
Generated code of this kind should never be allowed.
Move Name promotion implicits into companions.

This is important so that these implicits are only used for
promotion and not for conversion-and-selection. The latter
has two major liabilities: the loss of type safety (when
conversion-and-selection works) and when it doesn't work, it's
due to having broken some other implicit conversion which
has the same source type and a target type with a shared name.

A simple illustration:

  class A { }
  class B { def b = "" }
  val a = new A
  val b = new B
  def f = (a: B) // implicit conversion based on expected type
  def g = a.b    // implicit conversion-and-selection based on receiver type

What we see in 'f' is what we want for String => TermName and
String => TypeName. We do NOT want 'g' to compile, and we do not
want to create conflicts with other implicits which act on String,
such as StringOps. Furthermore, we do NOT want to be locked out of
placing standard method names such as "drop" directly onto Name,
where it is not intended as a magnet for implicit conversions.

There are three locations where one can define an implicit from
A => B in the above example:

  1) in A's companion object
  2) in B's companion object
  3) anywhere which is visible at the call site

At all three locations, 'f' compiles, but 'g' only compiles
in 2 out of 3.

  "How often have I said to you that when you have eliminated the
  impossible, whatever remains, however improbable, must be the truth?"

Today's improbability is that the String => TermName implicit must
be defined in the TermName object, and similarly for TypeName.
This makes sense: the expression "a.b" makes no reference to class B
at all, and implicit search isn't going to scour every corner of
the universe for types which have a 'b' member.