Fix MarshalAs IID parameter index parsing (#128364)

Fixes native AOT outerloop runs that are currently broken.

NativeAOT could assert while parsing valid `MarshalAs` metadata emitted
for COM interface parameters using `IidParameterIndex`, leaving unread
bytes in the marshal descriptor blob.

- **Parser**
- Consume optional `IidParameterIndex` payloads for COM interface native
types:
    - `IUnknown`
    - `IDispatch`
    - `Interface`
  - Keep existing behavior of using only the native type in NativeAOT.

- **Regression coverage**
  - Added TypeSystem coverage for descriptors like:

```csharp
[MarshalAs(UnmanagedType.Interface, IidParameterIndex = 0)] out object value
```

- Covered `Interface`, `IUnknown`, and `IDispatch` marshal descriptors.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: MichalStrehovsky <13110571+MichalStrehovsky@users.noreply.github.com>
Co-authored-by: Michal Strehovský <MichalStrehovsky@users.noreply.github.com>

Author: Copilot

src/coreclr/tools/Common/TypeSystem/Ecma/EcmaSignatureParser.cs

@@ -612,6 +612,18 @@ public MarshalAsDescriptor ParseMarshalAsDescriptor()
                         }
                     }
                     break;
+                case NativeTypeKind.IUnknown:
+                case NativeTypeKind.IDispatch:
+                case NativeTypeKind.Intf:
+                    {
+                        if (_reader.RemainingBytes != 0)
+                        {
+                            // There's nobody to consume COM marshalling, so let's just parse the data
+                            // to avoid asserting later.
+                            _reader.ReadCompressedInteger();
+                        }
+                    }
+                    break;
                 case NativeTypeKind.CustomMarshaler:
                     {
                         // Read typelib guid

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Marshalling.cs

@@ -179,5 +179,23 @@ public class ClassWithSequentialInt64Base : SequentialInt64Base
         public int i;
     }
 
+    public class MethodsWithMarshalAs
+    {
+        public void IUnknownWithIidParameterIndex(object iid, [MarshalAs(UnmanagedType.IUnknown, IidParameterIndex = 0)] out object value)
+        {
+            value = new object();
+        }
+
+        public void IDispatchWithIidParameterIndex(object iid, [MarshalAs(UnmanagedType.IDispatch, IidParameterIndex = 0)] out object value)
+        {
+            value = new object();
+        }
+
+        public void InterfaceWithIidParameterIndex(object iid, [MarshalAs(UnmanagedType.Interface, IidParameterIndex = 0)] out object value)
+        {
+            value = new object();
+        }
+    }
+
     #endregion
 }

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs

@@ -214,6 +214,7 @@ public enum UnmanagedType
     public sealed class MarshalAsAttribute : Attribute
     {
         public MarshalAsAttribute(UnmanagedType unmanagedType) { }
+        public int IidParameterIndex { get; set; }
     }
 
     public sealed class ComImportAttribute : Attribute

src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/MarshalUtilsTests.cs

@@ -80,5 +80,19 @@ public void IsBlittableType_TypeWithEmptyBase_ReturnsTrue(string className)
             TypeDesc classWithEmptyBase = _testModule.GetType("Marshalling"u8, Encoding.UTF8.GetBytes(className));
             Assert.True(MarshalUtils.IsBlittableType(classWithEmptyBase));
         }
+
+        [Theory]
+        [InlineData("IUnknownWithIidParameterIndex", NativeTypeKind.IUnknown)]
+        [InlineData("IDispatchWithIidParameterIndex", NativeTypeKind.IDispatch)]
+        [InlineData("InterfaceWithIidParameterIndex", NativeTypeKind.Intf)]
+        public void MarshalAsComInterface_WithIidParameterIndex_ParsesCorrectly(string methodName, NativeTypeKind nativeType)
+        {
+            MetadataType marshallingType = _testModule.GetType("Marshalling"u8, "MethodsWithMarshalAs"u8);
+            MethodDesc marshalAsMethod = marshallingType.GetMethod(Encoding.UTF8.GetBytes(methodName), null);
+
+            ParameterMetadata parameter = marshalAsMethod.GetParameterMetadata()[1];
+
+            Assert.Equal(nativeType, parameter.MarshalAsDescriptor.Type);
+        }
     }
 }