Fix missing Dispose override in SizeOptIListSelectIterator

Add Dispose() method to properly dispose the enumerator when
UseSizeOptimizedLinq is enabled. This fixes the bug where
custom enumerator's Dispose was not called when the source
implements IList<T>.

Fixes #115239

Co-authored-by: stephentoub <[email protected]>

Author: Copilot

src/libraries/System.Linq/src/System/Linq/Select.SizeOpt.cs

@@ -73,6 +73,17 @@ public override bool MoveNext()
                 return false;
             }
 
+            public override void Dispose()
+            {
+                if (_enumerator is not null)
+                {
+                    _enumerator.Dispose();
+                    _enumerator = null;
+                }
+
+                base.Dispose();
+            }
+
             public override TResult[] ToArray()
             {
                 TResult[] array = new TResult[_source.Count];

src/libraries/System.Linq/tests/SelectTests.cs

@@ -1261,5 +1261,89 @@ public static IEnumerable<object[]> RunSelectorDuringCountData()
                 }
             }
         }
+
+        [Fact]
+        public void Select_SourceIsIList_EnumeratorDisposedOnComplete()
+        {
+            var source = new DisposeTrackingList<int>([1, 2, 3, 4, 5]);
+
+            foreach (int item in source.Select(i => i * 2))
+            {
+            }
+
+            Assert.Equal(1, source.DisposeCalls);
+        }
+
+        [Fact]
+        public void Select_SourceIsIList_EnumeratorDisposedOnExplicitDispose()
+        {
+            var source = new DisposeTrackingList<int>([1, 2, 3, 4, 5]);
+
+            using (var enumerator = source.Select(i => i * 2).GetEnumerator())
+            {
+                enumerator.MoveNext();
+            }
+
+            Assert.Equal(1, source.DisposeCalls);
+        }
+
+        private sealed class DisposeTrackingList<T> : IList<T>, IReadOnlyList<T>
+        {
+            private readonly List<T> _list;
+            private int _disposeCalls;
+
+            public DisposeTrackingList(T[] items)
+            {
+                _list = [.. items];
+            }
+
+            public int DisposeCalls => _disposeCalls;
+
+            public T this[int index]
+            {
+                get => _list[index];
+                set => _list[index] = value;
+            }
+
+            public int Count => _list.Count;
+
+            public bool IsReadOnly => false;
+
+            public void Add(T item) => _list.Add(item);
+            public void Clear() => _list.Clear();
+            public bool Contains(T item) => _list.Contains(item);
+            public void CopyTo(T[] array, int arrayIndex) => _list.CopyTo(array, arrayIndex);
+            public int IndexOf(T item) => _list.IndexOf(item);
+            public void Insert(int index, T item) => _list.Insert(index, item);
+            public bool Remove(T item) => _list.Remove(item);
+            public void RemoveAt(int index) => _list.RemoveAt(index);
+
+            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+            public IEnumerator<T> GetEnumerator() => new DisposeTrackingEnumerator(this);
+
+            private sealed class DisposeTrackingEnumerator : IEnumerator<T>
+            {
+                private readonly DisposeTrackingList<T> _parent;
+                private readonly IEnumerator<T> _enumerator;
+
+                public DisposeTrackingEnumerator(DisposeTrackingList<T> parent)
+                {
+                    _parent = parent;
+                    _enumerator = parent._list.GetEnumerator();
+                }
+
+                public T Current => _enumerator.Current;
+                object? IEnumerator.Current => Current;
+                public bool MoveNext() => _enumerator.MoveNext();
+                public void Reset() => throw new NotSupportedException();
+
+                public void Dispose()
+                {
+                    _parent._disposeCalls++;
+                    _enumerator.Dispose();
+                }
+            }
+        }
     }
 }