fixup! feat: IndexedList and IIndexedList modules with the vocabulary of the FSharp.Core List module

Follows the reworked ADR 0001 (D2, D5) and the review of #31:

- `IndexedList`, `IIndexedList`, their `Option` and `Tuple` modules and `IndexedListBuilder` are the
  root modules of their files. The `IndexedList<'T>` abbreviation moves to
  `IndexedList/IndexedListTypes.fs`, which needs no signature file.
- `binarySearch`, the sorts of both modules and the sort of the builder compare with the cached
  `DefaultComparer<'T>.Instance`, so a call no longer creates a comparer.
- `IndexedList.rev` reverses a copy of the elements with `Array.Reverse` and builds the result with
  `ImmutableList.CreateRange`. At 100 000 elements, this is about 2.5 times faster than
  `ImmutableList.Reverse`, with the same allocation. `IIndexedList.rev` reverses its copy in place
  too and keeps the implementation of the input.
- `removeManyAt` of both modules removes nothing when `index + count` overflows, as
  `List.removeManyAt` does. Before, the range went to `RemoveRange`, which threw.
- `Helper.fs` gets the internal `Lengths` module for `Queue`, `Stack` and their interface modules:
  `queueUpTo` and `stackUpTo` count a queue or a stack only up to a limit.
- Two crefs name the right members: `FastGenericComparer` is a method, and the cref of `ofBuilder`
  writes the nested generic builder as the documentation ID does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: xperiandri

src/FSharp.Collections.Immutable/FSharp.Collections.Immutable.fsproj

@@ -32,6 +32,7 @@
     <Compile Include="FlatList\FlatListBuilder.fs" />
     <Compile Include="FlatList\FlatListCE.fsi" />
     <Compile Include="FlatList\FlatListCE.fs" />
+    <Compile Include="IndexedList\IndexedListTypes.fs" />
     <Compile Include="IndexedList\IndexedList.fsi" />
     <Compile Include="IndexedList\IndexedList.fs" />
     <Compile Include="IndexedList\IndexedListOption.fsi" />

src/FSharp.Collections.Immutable/Helper.fs

@@ -851,3 +851,68 @@ module internal Snapshot =
     let ofSeq (name : string) (source : seq<'T>) : 'T array =
         checkNotNull name source
         Enumerable.ToArray source
+
+/// <summary>
+/// The lengths of the stacks and the queues, which do not store their length, counted only as far as a caller needs them
+/// (ADR 0001, D5 and D6).
+/// </summary>
+/// <remarks>
+/// <para>
+/// The checks of <c>ListChecks</c> take a length, but most of them only tell an empty input from one with elements, or an
+/// input of one element from a longer one, and the sorts return an input of at most one element unchanged. A count of a
+/// whole stack or queue would make each of them O(n).
+/// </para>
+/// <para>
+/// The modules of <c>Queue</c>, <c>Stack</c> and their interface modules pass a limit instead: 1 to tell an empty input
+/// from one with elements, 2 to tell an input of one element from a longer one. The functions take the interfaces, which
+/// the concrete stack and queue implement, so that one function serves a module and its interface module.
+/// </para>
+/// </remarks>
+module internal Lengths =
+
+    /// Counts the elements up to the limit, stepping from a collection to the collection without its first element. The step
+    /// runs at most limit - 1 times, so a limit of 1 only reads whether the collection is empty.
+    let inline private countUpTo
+        ([<InlineIfLambda>] isEmpty : 'Collection -> bool)
+        ([<InlineIfLambda>] rest : 'Collection -> 'Collection)
+        (limit : int)
+        (collection : 'Collection)
+        =
+        let mutable remaining = collection
+        let mutable count = 0
+
+        while count < limit && not (isEmpty remaining) do
+            count <- count + 1
+
+            if count < limit then
+                remaining <- rest remaining
+
+        count
+
+    /// <summary>The number of elements of a queue, counted up to a limit: the length, or the limit for a longer queue.</summary>
+    /// <param name="limit">The largest number to count; a limit that is not positive gives 0.</param>
+    /// <param name="queue">The queue, which the caller has checked for <see langword="null"/>.</param>
+    /// <returns>The smaller of the length of the queue and the limit, and 0 for a limit that is not positive.</returns>
+    /// <remarks>
+    /// O(1) for a limit of 1, which only reads <see cref="P:System.Collections.Immutable.IImmutableQueue`1.IsEmpty"/>. A
+    /// larger limit calls <see cref="M:System.Collections.Immutable.IImmutableQueue`1.Dequeue"/> at most limit - 1 times.
+    /// Each call allocates a queue, and the call that takes the last element of the front of an
+    /// <see cref="T:System.Collections.Immutable.ImmutableQueue`1"/> reverses its back once, so the function suits small
+    /// limits.
+    /// </remarks>
+    let queueUpTo (limit : int) (queue : IImmutableQueue<'T>) =
+        countUpTo (fun (queue : IImmutableQueue<'T>) -> queue.IsEmpty) (fun queue -> queue.Dequeue ()) limit queue
+
+    /// <summary>The number of elements of a stack, counted up to a limit: the length, or the limit for a longer stack.</summary>
+    /// <param name="limit">
+    /// The largest number to count; a limit that is not positive gives 0, and <see cref="F:System.Int32.MaxValue"/> counts
+    /// the whole stack.
+    /// </param>
+    /// <param name="stack">The stack, which the caller has checked for <see langword="null"/>.</param>
+    /// <returns>The smaller of the length of the stack and the limit, and 0 for a limit that is not positive.</returns>
+    /// <remarks>
+    /// O(min(n, limit)), without an allocation: <see cref="M:System.Collections.Immutable.IImmutableStack`1.Pop"/> returns
+    /// the stack below the top element, which exists already.
+    /// </remarks>
+    let stackUpTo (limit : int) (stack : IImmutableStack<'T>) =
+        countUpTo (fun (stack : IImmutableStack<'T>) -> stack.IsEmpty) (fun stack -> stack.Pop ()) limit stack