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

The helpers of the branch get the documentation of `Arrays` and `ParallelArrays`: an explicit `<summary>`,
`<param>`, `<returns>`, `<exception>` and `<remarks>` for every function, and `<see cref>` instead of `<c>` for
every function and type of FSharp.Core. The remarks say why the function exists.

- `ListChecks`: every check names the functions of `List` that it serves, the exception that it throws (the
  type, the message and the parameter name) and, where a sibling check exists, why the two are separate
  (`item` and `removeAt` differ in the message, `replicate` and `nonNegative` in the value, `exists2` and
  `sameLengths` in the names, `zip3` and `map3` in the lengths, `notEmpty` and `notEmptySequence` in the
  word). `foldBack2` says why it has two branches, and `transpose` which pair of lists it reports, checked
  against `local.fs` of FSharp.Core. The private literal `IndexOutsideListBounds` says which five functions
  of `List` write it and why it is not in `ErrorStrings`.
- `ListArrays`: the summaries, the descriptions of the parameters and of the results are those of the
  functions of `List`. Each remark says why the function is not `Array.iter2` and its siblings: they compare
  the lengths before they call the callback and report arrays, where the functions of `List` call the
  callback for the common prefix first and report lists.
- `Snapshot`, `Lengths` (with its private `countUpTo`), `DescendingSorts` and `ListRanges`: parameters,
  results and exceptions, the reason for each function, and the functions that call it. The private literal
  of `ListRanges` said that its message is the one of System.Collections.Immutable; no resource of that
  assembly holds it. The runtime throws the message from ``List`1.BinarySearch`` with "array" and "source
  collection", and the literal says "list", so the comment says that.
- The three functions that the branch adds to `Raise` (`invalidArg2ListsDifferent`,
  `invalidArgRandomizerOutOfRange` and `invalidOpListEmpty`) replace one-line comments with backticks.

No code changed: without the doc comments, every file is identical to the file before. The build with
`--warnon:3390`, `dotnet fantomas --check` and a check of every `cref` against the generated XML
documentation, FSharp.Core and the reference assemblies are clean.

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

Author: xperiandri

src/FSharp.Collections.Immutable/Helper/DescendingSorts.fs

@@ -1,6 +1,7 @@
 /// <summary>
-/// The descending sorts of the modules that mirror <c>List</c>: the stable sorts of FSharp.Core, with the comparison of
-/// F# generic comparison that the type caches, and without the boxes of the inline sorts of <c>Seq</c> (ADR 0001, D5).
+/// The descending sorts of the modules that mirror <see cref="T:Microsoft.FSharp.Collections.ListModule"/>: stable sorts
+/// in the order of F# generic comparison, with the comparer that the type caches, and without the boxes of the inline
+/// sorts of <see cref="T:Microsoft.FSharp.Collections.SeqModule"/> (ADR 0001, D5).
 /// </summary>
 /// <remarks>
 /// <para>
@@ -13,7 +14,7 @@
 /// <para>
 /// The sorts here call
 /// <see cref="M:Microsoft.FSharp.Collections.SeqModule.SortWith``1(Microsoft.FSharp.Core.FSharpFunc{``0,Microsoft.FSharp.Core.FSharpFunc{``0,System.Int32}},System.Collections.Generic.IEnumerable{``0})"/>,
-/// which is not inline and runs the stable sort of <c>List</c>, with the comparer that
+/// which is not inline and runs the stable sort of <see cref="T:Microsoft.FSharp.Collections.ListModule"/>, with the comparer that
 /// <see cref="T:FSharp.Collections.Immutable.Comparers.DefaultComparer`1"/> caches for the type. The comparer compares
 /// as the generic operator does, so the comparisons, their order and the exceptions that they throw are those of
 /// <see cref="M:Microsoft.FSharp.Collections.ListModule.SortDescending``1(Microsoft.FSharp.Collections.FSharpList{``0})"/>
@@ -32,8 +33,18 @@ module internal FSharp.Collections.Immutable.DescendingSorts
 /// <param name="source">The elements, which the caller has checked for <see langword="null"/>.</param>
 /// <returns>The elements, equal elements in their order.</returns>
 /// <remarks>
-/// The comparer compares the second element with the first, as <c>List.sortDescending</c> does. The sort allocates
-/// the arrays of FSharp.Core and nothing per comparison, for a type that has a primitive comparer.
+/// <para>
+/// The comparer compares the second element with the first, as
+/// <see cref="M:Microsoft.FSharp.Collections.ListModule.SortDescending``1(Microsoft.FSharp.Collections.FSharpList{``0})"/>
+/// does. The sort allocates the arrays
+/// of FSharp.Core and nothing per comparison, for a type that has a primitive comparer.
+/// </para>
+/// <para>
+/// It exists instead of
+/// <see cref="M:Microsoft.FSharp.Collections.SeqModule.SortDescending``1(System.Collections.Generic.IEnumerable{``0})"/>,
+/// which boxes the elements of a value type in every comparison (see the
+/// remarks of the module).
+/// </para>
 /// </remarks>
 let sortDescending (source : seq<'T>) =
     let comparer = DefaultComparer<'T>.Instance
@@ -49,8 +60,17 @@ let sortDescending (source : seq<'T>) =
 /// <param name="source">The elements, which the caller has checked for <see langword="null"/>.</param>
 /// <returns>The elements, those with equal keys in their order.</returns>
 /// <remarks>
+/// <para>
 /// The projection runs in the comparison, twice for each comparison and for the second element first, as it does in
-/// <c>List.sortByDescending</c>; the keys are not computed beforehand.
+/// <see cref="M:Microsoft.FSharp.Collections.ListModule.SortByDescending``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},Microsoft.FSharp.Collections.FSharpList{``0})"/>;
+/// the keys are not computed beforehand.
+/// </para>
+/// <para>
+/// It exists instead of
+/// <see cref="M:Microsoft.FSharp.Collections.SeqModule.SortByDescending``2(Microsoft.FSharp.Core.FSharpFunc{``0,``1},System.Collections.Generic.IEnumerable{``0})"/>,
+/// which boxes the keys of a value type in every comparison (see the remarks
+/// of the module).
+/// </para>
 /// </remarks>
 let sortByDescending (projection : 'T -> 'Key) (source : seq<'T>) =
     let comparer = DefaultComparer<'Key>.Instance

src/FSharp.Collections.Immutable/Helper/Lengths.fs

@@ -5,9 +5,9 @@
 /// </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 queue or stack would make each of them O(n).
+/// The checks of <see cref="T:FSharp.Collections.Immutable.ListChecks"/> 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 queue or stack would make each of them O(n).
 /// </para>
 /// <para>
 /// The modules of the queues and the stacks pass a limit instead: 1 to tell an empty input from one with elements, 2 to
@@ -19,8 +19,25 @@ module internal FSharp.Collections.Immutable.Lengths
 
 open System.Collections.Immutable
 
-/// 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.
+/// <summary>
+/// Counts the elements of a collection up to a limit, by stepping from the collection to the collection without its first
+/// element.
+/// </summary>
+/// <param name="isEmpty">Tells whether a collection has no element.</param>
+/// <param name="rest">Returns the collection without its first element; the collection is not empty.</param>
+/// <param name="limit">The largest number to count.</param>
+/// <param name="collection">The collection to count.</param>
+/// <returns>The smaller of the number of elements and the limit, and 0 for a limit that is not positive.</returns>
+/// <remarks>
+/// <para>
+/// The step runs at most limit - 1 times, so a limit of 1 only reads whether the collection is empty.
+/// </para>
+/// <para>
+/// The queue and the stack differ only in how they tell that no element is left and how they step, so the loop exists
+/// once. It is inline and inlines its two functions, so that a count contains the calls of the interface members
+/// themselves, not calls of closures.
+/// </para>
+/// </remarks>
 let inline private countUpTo
     ([<InlineIfLambda>] isEmpty : 'Collection -> bool)
     ([<InlineIfLambda>] rest : 'Collection -> 'Collection)