Add Stream wrappers for memory and text-based types

Polyfills StringStream, ReadOnlyMemoryStream, WritableMemoryStream and
ReadOnlySequenceStream from dotnet/runtime#126669.

These types are approved for net11 but are not in the current net11 preview,
so they are gated on `#if FeatureMemory` and remain active on net11. When a
net11 SDK ships the real types, ApiBuilderTests.StreamWrapperBclDetectionTests
fails with the exact change to make in each file: flip the guard to
`#if FeatureMemory && !NET11_0_OR_GREATER` and add a TypeForwardedTo under
`#if NET11_0_OR_GREATER`. The same steps are documented atop each source file.

- ReadOnlyMemoryStream/WritableMemoryStream derive from MemoryStream and delegate
  to the MemoryStream(byte[],int,int,bool,bool) constructor, giving read-only /
  fixed-capacity semantics with GetBuffer throwing and TryGetBuffer returning
  false, without relying on MemoryStream internals unavailable on older TFMs.
- StringStream (non-seekable, never emits a BOM) and ReadOnlySequenceStream
  (seekable) derive from Stream.

Tests run on every framework where FeatureMemory is available; verified compiling
across all 22 TFMs and passing on net11.0 and net48.

Author: SimonCropp

src/ApiBuilderTests/BuildApiTest.cs

@@ -23,6 +23,10 @@ public Task RunWithRoslyn()
         WriteHelper("Utf16", writer, ref count);
         WriteType(nameof(TaskCompletionSource), writer, ref count);
         WriteType(nameof(UnreachableException), writer, ref count);
+        WriteType("StringStream", writer, ref count);
+        WriteType("ReadOnlyMemoryStream", writer, ref count);
+        WriteType("WritableMemoryStream", writer, ref count);
+        WriteType("ReadOnlySequenceStream", writer, ref count);
 
         count += Directory.EnumerateFiles(polyfillDir, "*Attribute.cs", SearchOption.AllDirectories).Count();
         // Index and Range

src/ApiBuilderTests/StreamWrapperBclDetectionTests.cs

@@ -0,0 +1,84 @@
+using System.Text;
+
+/// <summary>
+/// The Stream wrapper types from dotnet/runtime#126669 (StringStream, ReadOnlyMemoryStream,
+/// WritableMemoryStream, ReadOnlySequenceStream) were approved/merged for net11 but are NOT in the
+/// current net11 preview/RC. Polyfill therefore ships them as ACTIVE on net11 too.
+///
+/// This project (ApiBuilderTests) targets net11.0 and does NOT compile the polyfill source into
+/// itself, so it keeps building once the BCL gains these types. This test runs on the net11 runtime
+/// and fails the moment the real types appear, telling you exactly which guards to flip.
+/// </summary>
+public class StreamWrapperBclDetectionTests
+{
+    static readonly (string FullName, string File)[] pending =
+    [
+        ("System.IO.StringStream", "StringStream.cs"),
+        ("System.IO.ReadOnlyMemoryStream", "ReadOnlyMemoryStream.cs"),
+        ("System.IO.WritableMemoryStream", "WritableMemoryStream.cs"),
+        ("System.Buffers.ReadOnlySequenceStream", "ReadOnlySequenceStream.cs"),
+    ];
+
+    [Test]
+    public void StreamWrapperPolyfillsStillNeededOnNet11()
+    {
+        var present = new List<(string FullName, string File, string Assembly)>();
+        foreach (var (fullName, file) in pending)
+        {
+            var type = FindBclType(fullName);
+            if (type != null)
+            {
+                present.Add((fullName, file, type.Assembly.GetName().Name!));
+            }
+        }
+
+        if (present.Count == 0)
+        {
+            return;
+        }
+
+        var builder = new StringBuilder();
+        builder.AppendLine($"{present.Count} Stream wrapper type(s) from dotnet/runtime#126669 are now provided by the BCL");
+        builder.AppendLine($"on this runtime ({System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription}).");
+        builder.AppendLine("The matching Polyfill source now collides with the real type and must be retired for net11.");
+        builder.AppendLine("For EACH type below, edit the listed file under src/Polyfill/:");
+        builder.AppendLine();
+
+        foreach (var (fullName, file, assembly) in present)
+        {
+            builder.AppendLine($"  {fullName}  (now in {assembly})");
+            builder.AppendLine($"    file: src/Polyfill/{file}");
+            builder.AppendLine("    1. change `#if FeatureMemory` to `#if FeatureMemory && !NET11_0_OR_GREATER`");
+            builder.AppendLine("    2. append after the final #endif:");
+            builder.AppendLine("         #if NET11_0_OR_GREATER");
+            builder.AppendLine($"         [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof({fullName}))]");
+            builder.AppendLine("         #endif");
+            builder.AppendLine();
+        }
+
+        builder.AppendLine("Then re-run ApiBuilderTests in Debug to regenerate Split + api_list, and drop any now-redundant");
+        builder.AppendLine("usage from src/Consume/Consume.cs.");
+
+        throw new(builder.ToString());
+    }
+
+    static System.Type? FindBclType(string fullName)
+    {
+        foreach (var assembly in new[]
+                 {
+                     "System.Private.CoreLib",
+                     "System.Runtime",
+                     "System.Memory",
+                     "mscorlib"
+                 })
+        {
+            var type = System.Type.GetType($"{fullName}, {assembly}", throwOnError: false);
+            if (type is { IsPublic: true })
+            {
+                return type;
+            }
+        }
+
+        return null;
+    }
+}

src/Consume/Consume.cs

@@ -258,6 +258,39 @@ void Base64UrlUsage()
     }
 #endif
 
+#if FeatureMemory
+    void StreamWrappersUsage()
+    {
+        var bytes = new byte[10];
+
+        using (Stream stringStream = new StringStream("text", Encoding.UTF8))
+        {
+            stringStream.Read(bytes, 0, bytes.Length);
+        }
+
+        using (var stringStream = new StringStream("text".AsMemory(), Encoding.UTF8))
+        {
+            Encoding encoding = stringStream.Encoding;
+            stringStream.ReadByte();
+        }
+
+        using (MemoryStream readOnly = new ReadOnlyMemoryStream(new ReadOnlyMemory<byte>(bytes)))
+        {
+            readOnly.Read(bytes, 0, bytes.Length);
+        }
+
+        using (MemoryStream writable = new WritableMemoryStream(new Memory<byte>(bytes)))
+        {
+            writable.Write(bytes, 0, bytes.Length);
+        }
+
+        using (Stream sequenceStream = new System.Buffers.ReadOnlySequenceStream(new System.Buffers.ReadOnlySequence<byte>(bytes)))
+        {
+            sequenceStream.Read(bytes, 0, bytes.Length);
+        }
+    }
+#endif
+
 #if FeatureMemory && !RefsBclMemory
     void Base64Usage()
     {

src/Polyfill/ReadOnlyMemoryStream.cs

@@ -0,0 +1,74 @@
+#nullable enable
+
+// === Polyfill target window =====================================================================
+// System.IO.ReadOnlyMemoryStream was approved and merged into dotnet/runtime for net11
+// (https://github.com/dotnet/runtime/pull/126669) but is NOT in the current net11 preview/RC SDK,
+// so this polyfill is intentionally ACTIVE on net11 as well.
+// When you upgrade to a net11 SDK that actually ships this type, the build will collide (CS0436)
+// and the ApiBuilderTests "StreamWrapperBclDetectionTests" test FAILS with these exact steps.
+// To retire this polyfill for net11:
+//   1. change `#if FeatureMemory` below to `#if FeatureMemory && !NET11_0_OR_GREATER`
+//   2. add at the bottom of this file (after the final #endif):
+//        #if NET11_0_OR_GREATER
+//        [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.IO.ReadOnlyMemoryStream))]
+//        #endif
+//   3. re-run ApiBuilderTests in Debug to regenerate Split + api_list.
+// ================================================================================================
+#if FeatureMemory
+
+#pragma warning disable
+
+namespace System.IO;
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+/// <summary>
+/// Provides a seekable, read-only <see cref="MemoryStream"/> over a <see cref="ReadOnlyMemory{Byte}"/>.
+/// </summary>
+/// <remarks>
+/// The stream cannot be written to. <see cref="MemoryStream.CanWrite"/> always returns <see langword="false"/>.
+/// <see cref="MemoryStream.GetBuffer"/> throws and <see cref="MemoryStream.TryGetBuffer"/> returns <see langword="false"/>.
+/// When the supplied memory is not backed by an array (for example native memory) the polyfill copies it;
+/// the BCL always wraps the memory without copying.
+/// </remarks>
+[ExcludeFromCodeCoverage]
+[DebuggerNonUserCode]
+#if PolyUseEmbeddedAttribute
+[global::Microsoft.CodeAnalysis.EmbeddedAttribute]
+#endif
+//Link: https://learn.microsoft.com/en-us/dotnet/api/system.io.readonlymemorystream?view=net-11.0
+#if PolyPublic
+public
+#endif
+sealed class ReadOnlyMemoryStream :
+    MemoryStream
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReadOnlyMemoryStream"/> class over the specified <see cref="ReadOnlyMemory{Byte}"/>.
+    /// </summary>
+    //Link: https://learn.microsoft.com/en-us/dotnet/api/system.io.readonlymemorystream.-ctor?view=net-11.0
+    public ReadOnlyMemoryStream(ReadOnlyMemory<byte> source)
+        : base(GetArray(source, out var offset, out var count), offset, count, writable: false, publiclyVisible: false)
+    {
+    }
+
+    static byte[] GetArray(ReadOnlyMemory<byte> source, out int offset, out int count)
+    {
+        if (MemoryMarshal.TryGetArray(source, out var segment) &&
+            segment.Array != null)
+        {
+            offset = segment.Offset;
+            count = segment.Count;
+            return segment.Array;
+        }
+
+        var array = source.ToArray();
+        offset = 0;
+        count = array.Length;
+        return array;
+    }
+}
+
+#endif