SI-3452: Fix intersection types in generic signatures

Handle intersection types in generic signatures like in erased
descriptors.

When a method returns an intersection type, Scalac currently produces a generic
signature which is not coherent with the method descriptor.

The new handling of intersection types corresponds to
scala.reflect.internal.transform.Erasure.ScalaErasureMap.mergeParents,
which also calls intersectionDominator and is used to handle RefinedTypes
in scala.reflect.internal.transform.Erasure.ErasureMap.apply.

This change fixes problems with erasure of A with B in return
types. We still get a warning, but it is now spurious; however, this warning
implies that the generic signature is still omitted. I investigated the warning
to no success.

On this code, posted on SI-3452:

abstract class Foo
trait Bar2 extends Foo
class Test {
  def f6[T](t: T) = new Foo with Bar2 { }
  def f7[T](t: T) = new Bar2 { }
}

I got the warnings:

SI-3452/DescriptorExample.scala:13: warning: compiler bug: created generic signature for method f6 in Test that does not conform to its erasure
signature: <T:Ljava/lang/Object;>(TT;)LFoo;
original type: [T >: ? <: ?](t: Object)Foo with Bar2
normalized type: [T >: ? <: ?](t: Object)Foo with Bar2
erasure type: (t: Object)Bar2
if this is reproducible, please report bug at https://issues.scala-lang.org/
  def f6[T](t: T) = new Foo with Bar2 { }
SI-3452/DescriptorExample.scala:14: warning: compiler bug: created generic signature for method f7 in Test that does not conform to its erasure
signature: <T:Ljava/lang/Object;>(TT;)LFoo;
original type: [T >: ? <: ?](t: Object)Foo with Bar2
normalized type: [T >: ? <: ?](t: Object)Foo with Bar2
erasure type: (t: Object)Bar2
if this is reproducible, please report bug at https://issues.scala-lang.org/
  def f7[T](t: T) = new Bar2 { }

Note that the return type of the signature is Foo, while in the erasure
type it is Bar. With this patch, instead, the return type in the signature becomes also
Bar:
SI-3452/DescriptorExample.scala:13: warning: compiler bug: created generic signature for method f6 in Test that does not conform to its erasure
signature: <T:Ljava/lang/Object;>(TT;)LBar2;
original type: [T >: ? <: ?](t: Object)Foo with Bar2
normalized type: [T >: ? <: ?](t: Object)Foo with Bar2
erased normalized type: (t: Object)Foo
erasure type: (t: Object)Bar2
if this is reproducible, please report bug at https://issues.scala-lang.org/
  def f6[T](t: T) = new Foo with Bar2 { }
SI-3452/DescriptorExample.scala:14: warning: compiler bug: created generic signature for method f7 in Test that does not conform to its erasure
signature: <T:Ljava/lang/Object;>(TT;)LBar2;
original type: [T >: ? <: ?](t: Object)Foo with Bar2
normalized type: [T >: ? <: ?](t: Object)Foo with Bar2
erased normalized type: (t: Object)Foo
erasure type: (t: Object)Bar2
if this is reproducible, please report bug at https://issues.scala-lang.org/
  def f7[T](t: T) = new Bar2 { }

However, the 'erased normalized type' uses still the wrong type.
More debug info
Avoid spurious warnings due to the Nothing vs Nothing$ mismatch

When adding generic signatures, the compiler checks that the generic signature is coherent
with the result of erasure, otherwise drops the generic signature to workaround
SI-3452. In practice, the compiler approximates incorrectly this check by comparing
erasedNormalizedType and bytecodeTpe.
Therefore, we currently get many spurious warnings because erasedNormalizedType
and the generic signature use scala.runtime.Nothing$, while bytecodeTpe (the
result of the erasure phase) mentions scala.Nothing.
In fact, the correct type is scala.runtime.Nothing$, but the replacement is done
at a later stage for descriptors - in particular during code generation by
GenJVMUtil.javaNameCache.
I would propose to consider moving it as a better solution, unless there is a
strong reason against this; otherwise, we could also remove the substitution
from prepareSigMap, but I believe the author of prepareSigMap was correct in
assuming that erasure is complete after the erasure phase! I took a look at the
erasure code, but I was unable to figure out where to insert the needed
substitution without ruining everything.

Additionally, a testcase is needed for the Null return type, since I never
observed a warning for it.

Example warning before this patch:

src/actors/scala/actors/InternalActor.scala:221: warning:
compiler bug: created generic signature for method reactWithin in scala.actors.InternalActor that does not conform to its erasure
signature: (JLscala/PartialFunction<Ljava/lang/Object;Lscala/runtime/BoxedUnit;>;)Lscala/runtime/Nothing$;
original type: (msec: Long, handler: PartialFunction)Nothing
normalized type: (msec: Long, handler: PartialFunction)scala.runtime.Nothing$
erasure type: (msec: Long, handler: PartialFunction)Nothing
Add TODO about warning