SI-7553 Propagate type of unstable args through dependent methods

After a soundness fix in SI-3873, instantiation of dependent
method type results behaved differently for if the argument
from which we were propagating information had a stable type
or not. This is particular to substutition into singleton types
over the parameter in question.

If the argument was stable, it was substituted into singleton
types, such as the one below in the prefix in `a.type#B`
(which is the longhand version of `a.B`)

	scala> class A { type B >: Null <: AnyRef }
	defined class A

	scala> object AA extends A { type B = String }
	defined object AA

	scala> def foo(a: A): a.B = null
	foo: (a: A)a.B

	scala> foo(AA)
	res0: AA.B = null

But what if it isn't stable?

	scala> foo({def a = AA; a: A { type B <: String}})
	res3: a.B = null

This commit changes that to:

	scala> foo({def a = AA; a: A { type B <: String}})
	res1: a.type with A{type B <: String}#B = null

That oddly printed type is missing parens: it should be:

    (a.type with A{type B <: String})#B

It is is a protection from refinement that combines:
  a) the singleton type on the parameter
  b) the type of the argument

I also had to change InstantiateTypeMap to be top-down rather
than bottom up, so that the alias substitution kicks in before
this refinement was created.

Otherwise, we got:

	 /localhome/jenkins/a/workspace/scala-checkin-manual/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala:123: error: type mismatch;
	[quick.compiler]  found   : cs.type with MatchTranslator.this.TypeTestTreeMaker.TypeTestCondStrategy{type Result = Boolean}#<none>
	[quick.compiler]  required: Boolean