Scenario is very rare, but quite simple: you define a generic class, then create a nested class which inherits from outer class and define a associative field (of self type) wit
The core of your question is why Inner.Inner is a different type than Inner. Once you understand that, your observations about compile time and generated IL code size follow easily.
The first thing to note is that when you have this declaration
public class X
{
public class Y { }
}
There are infinitely many types associated with the name Y. There is one for each generic type argument T, so X is different than X, and, important for later, X is a different type than X for all T's. You can test this for various types T.
The next thing to note is that in
public class A
{
public class B : A { }
}
There are infinitely many ways to refer to nested type B. One is A.B, another is A.B.B, and so on. The statement typeof(A.B) == typeof(A.B.B) returns true.
When you combine these two, the way you have done, something interesting happens. The type Outer is not the same type as Outer. Outer is a subclass of Outer while Outer is a subclass of Outer, which we established before as being different from Outer. So Outer and Outer are referring to different types.
When generating IL, the compiler always uses fully qualified names for types. You have cleverly found a way to refer to types with names whose lengths that grow at exponential rates. That is why as you increase the generic arity of Outer or add additional levels .Y to the field field in Inner the output IL size and compile time grow so quickly.