Add WebCIL / WASM container support to the structural R2R reader

Port the runtime's WebcilImageReader (from dotnet/runtime#128423) to the
standalone structural ReadyToRun reader, implementing IPlatformBinaryReader
for raw .webcil images and WebCIL payloads embedded in WASM modules.

- Wasm/WasmMachine.cs: Wasm32 = (Machine)0xFFFE placeholder machine value.
- Webcil/WebcilFormat.cs: Webcil header/section structs and constants.
- Webcil/WebcilImageReader.cs: header/section parsing, RVA->offset
  translation, R2R header location via the COR header
  ManagedNativeHeaderDirectory, pinned MetadataReader access, and
  WASM-wrapper detection (passive data segment scan). The r2rdump-only
  WASM disassembly helpers are intentionally omitted.
- ReadyToRunReader.TargetPointerSize maps Wasm32 -> 4.
- R2RAssertions.CreateCore detects WebCIL/WASM and selects the new reader.

Regression tests build minimal hand-constructed WebCIL R2R images (raw and
WASM-wrapped, v0 and v1 headers, single- and two-section layouts) and cover
detection, machine/pointer size, header/section parsing, exact RVA byte
mapping, ECMA-335 metadata reads, decoy WASM segments, and malformed-input
error paths.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: jtschuster

src/ILCompiler.Reflection.ReadyToRun.Structural.Assertions/R2RAssertions.cs

@@ -74,13 +74,18 @@ private static R2RAssertions CreateCore(byte[] imageBytes, string filename, stri
         {
             bool isMachO = imageBytes.Length >= 4
                 && imageBytes[0] == 0xCF && imageBytes[1] == 0xFA && imageBytes[2] == 0xED && imageBytes[3] == 0xFE;
+            bool isWebcil = !isMachO && Webcil.WebcilImageReader.IsWebcilImage(imageBytes);
 
             PEReader peReader = null;
             IPlatformBinaryReader imageReader;
             if (isMachO)
             {
                 imageReader = new MachO.MachOImageReader(imageBytes);
             }
+            else if (isWebcil)
+            {
+                imageReader = new Webcil.WebcilImageReader(imageBytes);
+            }
             else
             {
                 peReader = new PEReader(new MemoryStream(imageBytes));

src/ILCompiler.Reflection.ReadyToRun.Structural/ReadyToRunReader.cs

@@ -81,6 +81,7 @@ public int TargetPointerSize
                 {
                     Machine.I386 or Machine.Arm or Machine.Thumb or Machine.ArmThumb2 => 4,
                     Machine.Amd64 or Machine.Arm64 or Machine.LoongArch64 or Machine.RiscV64 => 8,
+                    WasmMachine.Wasm32 => 4,
                     _ => throw new NotImplementedException(Machine.ToString()),
                 };
             }

src/ILCompiler.Reflection.ReadyToRun.Structural/Wasm/WasmMachine.cs

@@ -0,0 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.PortableExecutable;
+
+namespace System.Reflection.Metadata.ReadyToRun
+{
+    /// <summary>
+    /// WebAssembly does not have a dedicated <see cref="Machine"/> value, so ReadyToRun images
+    /// produced for wasm targets use a placeholder. This mirrors <c>WasmMachine.Wasm32</c> in the
+    /// runtime's <c>ILCompiler.Reflection.ReadyToRun</c>.
+    /// </summary>
+    public static class WasmMachine
+    {
+        /// <summary>Placeholder <see cref="Machine"/> value used for 32-bit WebAssembly images.</summary>
+        public const Machine Wasm32 = (Machine)0xFFFE;
+    }
+}

src/ILCompiler.Reflection.ReadyToRun.Structural/Webcil/WebcilFormat.cs

@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Reflection.Metadata.ReadyToRun.Webcil
+{
+    /// <summary>
+    /// Constants describing the Webcil container format.
+    /// Mirrors <c>WebcilConstants</c> in <c>src/coreclr/tools/Common/Wasm/Webcil.cs</c>.
+    /// </summary>
+    internal static class WebcilConstants
+    {
+        public const int WC_VERSION_MAJOR = 1;
+        public const int WC_VERSION_MINOR = 0;
+
+        /// <summary>
+        /// 'WbIL' magic bytes interpreted as a little-endian uint32.
+        /// </summary>
+        public const uint WEBCIL_MAGIC = 0x4c496257;
+
+        /// <summary>Size of a v0 Webcil header in bytes.</summary>
+        public const int V0HeaderSize = 28;
+
+        /// <summary>Size of a v1 Webcil header in bytes (adds <see cref="WebcilHeader.TableBase"/>).</summary>
+        public const int V1HeaderSize = 32;
+
+        /// <summary>Size of a single Webcil section header in bytes.</summary>
+        public const int SectionHeaderSize = 16;
+    }
+
+    /// <summary>
+    /// The header of a Webcil file. The header is a subset of the PE, COFF and CLI headers that are
+    /// needed by the runtime to load managed assemblies.
+    /// Mirrors <c>WebcilHeader</c> in <c>src/coreclr/tools/Common/Wasm/Webcil.cs</c>.
+    /// </summary>
+    internal struct WebcilHeader
+    {
+        public uint Id;
+        public ushort VersionMajor;
+        public ushort VersionMinor;
+
+        public ushort CoffSections;
+#pragma warning disable CS0649 // Reserved0 mirrors the on-disk layout but is never read.
+        public ushort Reserved0;
+#pragma warning restore CS0649
+
+        public uint PeCliHeaderRva;
+        public uint PeCliHeaderSize;
+
+        public uint PeDebugRva;
+        public uint PeDebugSize;
+
+        // Present only in v1 headers.
+        public uint TableBase;
+    }
+
+    /// <summary>
+    /// Represents a section header in a Webcil file. This is the Webcil analog of
+    /// <see cref="System.Reflection.PortableExecutable.SectionHeader"/>, but with fewer fields.
+    /// </summary>
+    internal readonly struct WebcilSectionHeader
+    {
+        public readonly uint VirtualSize;
+        public readonly uint VirtualAddress;
+        public readonly uint SizeOfRawData;
+        public readonly uint PointerToRawData;
+
+        public WebcilSectionHeader(uint virtualSize, uint virtualAddress, uint sizeOfRawData, uint pointerToRawData)
+        {
+            VirtualSize = virtualSize;
+            VirtualAddress = virtualAddress;
+            SizeOfRawData = sizeOfRawData;
+            PointerToRawData = pointerToRawData;
+        }
+    }
+}