Improve GreenNode.ToString() implementation for efficiency (#12344)

> [!TIP]
> I recommend reviewing this PR commit-by-commit. Each commit represents
a concrete change and includes a description.

The key improvement in this change is to take advantage of the fact that
a green node's width is the same as the length of the string produced by
`ToString()`. So, we can use the width to call `string.Create(...)` and
efficiently create the string rather than building it up with a
`StringWriter`.

Using a `StringWriter` requires all of the characters to first be copied
into the writer's underlying `StringBuilder` and then copy them *again*
when creating the final string. We can avoid this extra copying by using
`string.Create(...)` and copying the characters directly into the final
string. The end result is a simpler implementation that avoids the need
for a `StringWriter` pool.

----
CI Build:
https://dev.azure.com/dnceng/internal/_build/results?buildId=2817951&view=results
Test Insertion:
https://dev.azure.com/devdiv/DevDiv/_git/VS/pullrequest/680209
Toolset Run:
https://dev.azure.com/dnceng/internal/_build/results?buildId=2817952&view=results

Author: DustinCampbell

src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Syntax/GreenNodeTests.cs

@@ -118,7 +118,7 @@ internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index)
     /// </summary>
     internal static SyntaxNodeOrToken ItemInternal(SyntaxNode node, int index, ref SlotData slotData)
     {
-        GreenNode greenChild;
+        GreenNode? greenChild;
         var green = node.Green;
 
         // slotData may contain information that allows us to start the loop below using data
@@ -289,7 +289,7 @@ internal static SyntaxNodeOrToken ChildThatContainsPosition(SyntaxNode node, int
     /// </summary>
     internal static SyntaxNode? ItemInternalAsNode(SyntaxNode node, int index, ref SlotData slotData)
     {
-        GreenNode greenChild;
+        GreenNode? greenChild;
         var green = node.Green;
         var idx = index - slotData.PrecedingOccupantSlotCount;
         var slotIndex = slotData.SlotIndex;

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/ChildSyntaxList.cs

@@ -0,0 +1,69 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Razor.Language.Syntax;
+
+internal abstract partial class GreenNode
+{
+    /// <summary>
+    ///  Provides a depth-first enumerator for traversing <see cref="GreenNode"/> syntax trees.
+    ///  List nodes are treated as "transparent" and are not returned during enumeration,
+    ///  only their children are processed.
+    /// </summary>
+    /// <remarks>
+    ///  This enumerator uses a stack-based approach to traverse the syntax tree without recursion.
+    ///  It pushes child nodes in reverse order to maintain correct left-to-right traversal order.
+    ///  The enumerator must be disposed to release the underlying stack resources.
+    /// </remarks>
+    public ref struct Enumerator
+    {
+        private MemoryBuilder<GreenNode> _stack;
+        private GreenNode? _current;
+
+        public Enumerator(GreenNode node)
+        {
+            // MemoryBuilder<T> uses ArrayPool<T>.Shared to acquire an array.
+            // So, we set an initial capacity of 256 to avoid unnecessary growth.
+            // In addition, because the arrays used by MemoryBuilder<T> will be
+            // returned to the pool, we clear them to ensure that GreenNodes aren't
+            // kept in memory.
+            _stack = new(initialCapacity: 256, clearArray: true);
+            _stack.Push(node);
+        }
+
+        public void Dispose()
+        {
+            _stack.Dispose();
+        }
+
+        public readonly GreenNode Current => _current!;
+
+        public bool MoveNext()
+        {
+            while (_stack.TryPop(out var node))
+            {
+                // Push children onto the stack in reverse order for correct traversal order.
+                for (var i = node.SlotCount - 1; i >= 0; i--)
+                {
+                    var child = node.GetSlot(i);
+                    if (child != null)
+                    {
+                        _stack.Push(child);
+                    }
+                }
+
+                // If this is not a list node, return it as the current item.
+                // List nodes are "transparent" - we push their children but don't return the list itself.
+                if (!node.IsList)
+                {
+                    _current = node;
+                    return true;
+                }
+            }
+
+            // Stack is empty, no more nodes to process
+            _current = null;
+            return false;
+        }
+    }
+}

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNode.Enumerator.cs

@@ -0,0 +1,49 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Razor.Language.Syntax;
+
+internal abstract partial class GreenNode
+{
+    /// <summary>
+    ///  Provides enumeration over only the tokens within a <see cref="GreenNode"/> syntax tree,
+    ///  filtering out non-token nodes during traversal.
+    /// </summary>
+    public readonly ref struct TokenEnumerable(GreenNode node)
+    {
+        public Enumerator GetEnumerator()
+            => new(node);
+
+        /// <summary>
+        ///  Enumerates only the tokens within a <see cref="GreenNode"/> syntax tree,
+        ///  automatically filtering out non-token nodes during traversal.
+        /// </summary>
+        public ref struct Enumerator(GreenNode node)
+        {
+            private GreenNode.Enumerator _enumerator = node.GetEnumerator();
+            private InternalSyntax.SyntaxToken? _current;
+
+            public void Dispose()
+            {
+                _enumerator.Dispose();
+            }
+
+            public readonly InternalSyntax.SyntaxToken Current => _current!;
+
+            public bool MoveNext()
+            {
+                while (_enumerator.MoveNext())
+                {
+                    if (_enumerator.Current.IsToken)
+                    {
+                        _current = (InternalSyntax.SyntaxToken)_enumerator.Current;
+                        return true;
+                    }
+                }
+
+                _current = null;
+                return false;
+            }
+        }
+    }
+}