Make computation of arguments for raw types lazy

See how we translate raw types to Kotlin model:
RawType(A) = A<ErasedUpperBound(T1), ...>
ErasedUpperBound(T : G<t>) = G<*> // UpperBound(T) is a type G<t> with arguments
ErasedUpperBound(T : A) = A // UpperBound(T) is a type A without arguments
ErasedUpperBound(T : F) = UpperBound(F) // UB(T) is another type parameter F

Stack overflow happens with the following classes:
class A<X extends B> // NB: raw type B in upper bound
class B<Y extends A> // NB: raw type A in upper bound

when calculating raw type for A, we start calculate ErasedUpperBound(Y),
thus starting calculating raw type for B => ErasedUpperBound(X) => RawType(A),
so we have SOE here.
The problem is that we calculating the arguments for these raw types eagerly,
while from the definition of ErasedUpperBound(Y) we only need a type constructor
of raw type B (and the number of parameters), we don't use its arguments.

The solution is to make arguments calculating for raw types lazy

 #KT-16528 Fixed

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt

@@ -218,8 +218,10 @@ class JavaTypeResolver(
                 //   so we get A<*, *>.
                 // Summary result for upper bound of T is `A<A<*, *>, A<*, *>>..A<out A<*, *>, out A<*, *>>`
                 val erasedUpperBound =
-                        parameter.getErasedUpperBound(attr.upperBoundOfTypeParameter) {
-                            constructor.declarationDescriptor!!.defaultType.replaceArgumentsWithStarProjections()
+                        LazyWrappedType(c.storageManager) {
+                            parameter.getErasedUpperBound(attr.upperBoundOfTypeParameter) {
+                                constructor.declarationDescriptor!!.defaultType.replaceArgumentsWithStarProjections()
+                            }
                         }
 
                 RawSubstitution.computeProjection(parameter, attr, erasedUpperBound)