Allow refinements that refine already refined types.

Previously, a double definition errorfor `T` was produced in a case like this:

     type T1 = C { T <: A }
     type T2 = T1 { T <: B }

This was caused by the way T1 was treated in the refinement class
that is used to typecheck the type. Desugaring of T2 with `refinedTypeToClass`
would give

     trait <refinement> extends T1 { type T <: B }

and `normalizeToClassRefs` would transform this to:

     trait <refinement> extends C { type T <: A; type T <: B }

Hence the double definition. The new scheme desugars the rhs of `T2` to:

     trait <refinement> extends C { this: T1 => type T <: B }

which avoids the problem.

Also, added tests that #232 (fix/boundsPropagation) indeed considers all refinements
together when comparing refined types.

Supersedes #243. Review by @retronym please.
Agreed. I remember this coming up as a rough edge between value classes and structural types:

```
scala> def foo(c: { def t} ) = c.t
warning: there was one feature warning; re-run with -feature for details
foo: (c: AnyRef{def t: Unit})Unit

scala> foo(new T {})
<console>:10: error: object creation impossible, since method t in trait T of type => Unit is not defined
              foo(new T {})
                      ^
```

It would be interesting to experiment with changing this in scalac and  running the community build to find out how compatible it is.