Optimize index bounds check for immutable sorted set and list (#53266)

* Optimize index bounds check for immutable sorted set and list
- The bounds check to determine if a given index is >= 0 and < this.Count
  is only necessary on the first call to ItemRef.
- The recursive steps within ItemRef do not need to continuously
  do this bounds check on these immutable data structures.
- Proof:
  Elimination of index >= 0 bounds check:
    The first call to ItemRef checks if index >= 0.
    If we recurse on the left node, the index value does not change.
    If we recurse on the right node, index > _left._count. Then
    index - _left._count - 1 >= 0.

  Elimination of index < this.Count:
    The first call to ItemRef checks if index < this.Count. Then
    the given index must lie somewhere in this tree and
    (**) index < this.Count == left.Count + right.Count + 1.
    If we recurse on the left node, the index value does not change
    and a check is already made to determine that index < _left.Count.
    If we recurse on the right node, then we need to be sure that
    index - _left.count - 1 < _right.Count. But this is just a
    rearrangement of (**).

* Remove redundant code

* Remove redundant assert

* Apply suggestions from code review

Change from internal to private for unchecked methods.

Co-authored-by: Stephen Toub <stoub@microsoft.com>

Co-authored-by: Stephen Toub <stoub@microsoft.com>

Author: L2

src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Node.cs

@@ -195,15 +195,20 @@ internal ref readonly T ItemRef(int index)
             {
                 Requires.Range(index >= 0 && index < this.Count, nameof(index));
 
+                return ref ItemRefUnchecked(index);
+            }
+
+            private ref readonly T ItemRefUnchecked(int index)
+            {
                 Debug.Assert(_left != null && _right != null);
                 if (index < _left._count)
                 {
-                    return ref _left.ItemRef(index);
+                    return ref _left.ItemRefUnchecked(index);
                 }
 
                 if (index > _left._count)
                 {
-                    return ref _right.ItemRef(index - _left._count - 1);
+                    return ref _right.ItemRefUnchecked(index - _left._count - 1);
                 }
 
                 return ref _key;

src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Node.cs

@@ -260,16 +260,22 @@ internal T this[int index]
             internal ref readonly T ItemRef(int index)
             {
                 Requires.Range(index >= 0 && index < this.Count, nameof(index));
+
+                return ref ItemRefUnchecked(index);
+            }
+
+            private ref readonly T ItemRefUnchecked(int index)
+            {
                 Debug.Assert(_left != null && _right != null);
 
                 if (index < _left._count)
                 {
-                    return ref _left.ItemRef(index);
+                    return ref _left.ItemRefUnchecked(index);
                 }
 
                 if (index > _left._count)
                 {
-                    return ref _right.ItemRef(index - _left._count - 1);
+                    return ref _right.ItemRefUnchecked(index - _left._count - 1);
                 }
 
                 return ref _key;