Have CodeGenerationConstructedNamedTypeSymbol hold onto an unconstructed base

Our constructed type symbol was holding onto an abstract type symbol;
this allowed a constructed type to be created atop another constructed
type, which would form a chain. That isn't really necessary, and doesn't
match the usual mental models. This switches to holding onto a stronger
type, and then updates the Construct methods to go back to the prior
ConstructedFrom in order to avoid creating a chain.

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationAbstractNamedTypeSymbol.cs

@@ -53,13 +53,13 @@ public INamedTypeSymbol Construct(params ITypeSymbol[] typeArguments)
             }
 
             return new CodeGenerationConstructedNamedTypeSymbol(
-                this, typeArguments.ToImmutableArray(), this.TypeMembers);
+                ConstructedFrom, typeArguments.ToImmutableArray(), this.TypeMembers);
         }
 
         public INamedTypeSymbol Construct(ImmutableArray<ITypeSymbol> typeArguments, ImmutableArray<NullableAnnotation> typeArgumentNullableAnnotations)
         {
             return new CodeGenerationConstructedNamedTypeSymbol(
-                this, typeArguments, this.TypeMembers);
+                ConstructedFrom, typeArguments, this.TypeMembers);
         }
 
         public abstract int Arity { get; }
@@ -70,7 +70,8 @@ public INamedTypeSymbol Construct(ImmutableArray<ITypeSymbol> typeArguments, Imm
         public abstract IEnumerable<string> MemberNames { get; }
         public abstract IMethodSymbol DelegateInvokeMethod { get; }
         public abstract INamedTypeSymbol EnumUnderlyingType { get; }
-        public abstract INamedTypeSymbol ConstructedFrom { get; }
+        protected abstract CodeGenerationNamedTypeSymbol ConstructedFrom { get; }
+        INamedTypeSymbol INamedTypeSymbol.ConstructedFrom => this.ConstructedFrom;
         public abstract INamedTypeSymbol ConstructUnboundGenericType();
         public abstract ImmutableArray<IMethodSymbol> InstanceConstructors { get; }
         public abstract ImmutableArray<IMethodSymbol> StaticConstructors { get; }

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationConstructedNamedTypeSymbol.cs

@@ -8,11 +8,11 @@ namespace Microsoft.CodeAnalysis.CodeGeneration
 {
     internal class CodeGenerationConstructedNamedTypeSymbol : CodeGenerationAbstractNamedTypeSymbol
     {
-        private readonly CodeGenerationAbstractNamedTypeSymbol _constructedFrom;
+        private readonly CodeGenerationNamedTypeSymbol _constructedFrom;
         private readonly ImmutableArray<ITypeSymbol> _typeArguments;
 
         public CodeGenerationConstructedNamedTypeSymbol(
-            CodeGenerationAbstractNamedTypeSymbol constructedFrom,
+            CodeGenerationNamedTypeSymbol constructedFrom,
             ImmutableArray<ITypeSymbol> typeArguments,
             ImmutableArray<CodeGenerationAbstractNamedTypeSymbol> typeMembers)
             : base(constructedFrom.ContainingType, constructedFrom.GetAttributes(),
@@ -48,7 +48,7 @@ internal class CodeGenerationConstructedNamedTypeSymbol : CodeGenerationAbstract
                 // NOTE(cyrusn): remember to Construct the result if we implement this.
                 null;
 
-        public override INamedTypeSymbol ConstructedFrom => _constructedFrom;
+        protected override CodeGenerationNamedTypeSymbol ConstructedFrom => _constructedFrom;
 
         public override INamedTypeSymbol ConstructUnboundGenericType()
         {

src/Workspaces/Core/Portable/CodeGeneration/Symbols/CodeGenerationNamedTypeSymbol.cs

@@ -93,7 +93,7 @@ public override IMethodSymbol DelegateInvokeMethod
 
         public override INamedTypeSymbol EnumUnderlyingType => _enumUnderlyingType;
 
-        public override INamedTypeSymbol ConstructedFrom
+        protected override CodeGenerationNamedTypeSymbol ConstructedFrom
         {
             get
             {