fixup! docs: FrozenSet in the changelog and the collection table

The changelog lists the new `ofReadOnlySpan` and `ofSpan` of `FrozenSet` and the members of
`CustomComparerFrozenSet`. It says what a user of the BCL type does differently: the
replacements of `Create(comparer, ...)` and `ToFrozenSet(source, comparer)`, a `null`
comparer, `TryGetValue`, `Items` and `CopyTo`, the sequence forms of the relations,
`Add` and `Remove` through `union` and `difference`, the mutating interface members, which
element stays when the comparer finds two equal, and the alternate lookups.

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

Author: xperiandri

CHANGELOG.md

@@ -57,15 +57,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   a `null` comparer throws `ArgumentNullException`.
 * `FrozenSet` works on `System.Collections.Frozen.FrozenSet<'T>` with the functions of the FSharp.Core `Set` module that
   read a set or transform a whole set, with their semantics, argument order and exceptions, plus `choose`, `comparer`,
-  `forComparer`, `overlaps`, `setEquals`, `symmetricDifference`, `toFlatList`, which returns the elements without a copy,
-  and `tryGetValue`. A frozen set is built once: the module has no function that adds or removes an element, and every
-  transformation builds a new frozen set.
+  `forComparer`, `ofReadOnlySpan`, `ofSpan`, `overlaps`, `setEquals`, `symmetricDifference`, `toFlatList`, which returns
+  the elements without a copy, and `tryGetValue`. A frozen set is built once: the module has no function that adds or
+  removes an element, and every transformation builds a new frozen set. `FrozenSet.union set (FrozenSet.singleton value)`
+  and `FrozenSet.difference set (FrozenSet.singleton value)` do what `Set.add` and `Set.remove` do, each as an O(n)
+  rebuild that compares in the comparer of `set`.
+* `FrozenSet.ofReadOnlySpan` and `ofSpan` create a frozen set from a span. They wrap `FrozenSet.Create`, and of the
+  elements that the comparer finds equal the first stays.
 * `FrozenSet.forComparer comparer` creates the `CustomComparerFrozenSet` struct, whose members `empty`, `ofArray`,
-  `ofList`, `ofSeq` and `singleton` create frozen sets that compare with the comparer, as in
-  `(FrozenSet.forComparer StringComparer.OrdinalIgnoreCase).ofSeq names`. `ofSeq` also gives an existing frozen set the
-  comparer. A `null` comparer throws `ArgumentNullException`.
+  `ofList`, `ofReadOnlySpan`, `ofSeq`, `ofSpan` and `singleton` create frozen sets that compare with the comparer, as in
+  `(FrozenSet.forComparer StringComparer.OrdinalIgnoreCase).ofSeq names`. They replace the BCL methods
+  `FrozenSet.Create(comparer, ...)` and `ToFrozenSet(source, comparer)`; `ToFrozenSet` has no `optimizeForReading`
+  parameter in the package that the library references, so nothing is lost. `ofSeq` also gives an existing frozen set the
+  comparer, as `ToFrozenSet` does: the frozen set itself comes back when its comparer equals the comparer of the struct.
+  A `null` comparer throws `ArgumentNullException`, where the BCL methods take it as the default comparer:
+  `FrozenSet.ofSeq set` gives a frozen set the default comparer, and the default value of the struct has the BCL meaning.
+* The members of `FrozenSet<'T>` map to the module as follows. `TryGetValue(x, out v)` is `tryGetValue x set`, which
+  returns a `voption` (`Option.FrozenSet.tryGetValue` returns an `option`). `Items` is `toFlatList`, and `CopyTo` is
+  `toFlatList` followed by `FlatList.blit` or `FlatList.asSpan`. `IsSubsetOf`, `IsProperSubsetOf`, `IsSupersetOf`,
+  `IsProperSupersetOf`, `Overlaps` and `SetEquals` take frozen sets in the module, as the `Set` functions do: pass
+  `FrozenSet.ofSeq elements`, or `(FrozenSet.forComparer (FrozenSet.comparer set)).ofSeq elements` to give the elements
+  the comparer of the first frozen set; `Overlaps` and `IsSupersetOf` with a sequence are `Seq.exists` and `Seq.forall`
+  with `FrozenSet.contains`. The mutating members of the interfaces, such as `ISet<T>.UnionWith` and `ICollection<T>.Add`,
+  throw `NotSupportedException` on the BCL type and have no function.
+* `FrozenSet`: the element that stays when the comparer finds two elements equal follows the BCL. `union` keeps the
+  element of the first frozen set, `intersect` keeps the elements of the second one, as `ImmutableHashSet.Intersect` and
+  `ImmutableSortedSet.Intersect` do, because `FrozenSet<'T>` has no such member, and the creation functions keep the
+  first element of their input. `isProperSuperset` counts the elements of the second frozen set that the comparer of the
+  first one finds equal once, as `FrozenSet<'T>.IsProperSupersetOf` does.
 * On `net10.0`, `FrozenSet.alternateLookup` and `FrozenSet.tryAlternateLookup` return the alternate lookup of a frozen set
-  whose comparer compares the elements with values of another type.
+  whose comparer compares the elements with values of another type. They are `GetAlternateLookup` and
+  `TryGetAlternateLookup`. The alternate type comes first, as in `FrozenSet.alternateLookup<int, _> set`, and a lookup by a
+  `ReadOnlySpan<char>` calls the BCL method directly, because an F# generic function cannot be instantiated with a
+  byref-like type.
 * The `FSharp.Collections.Immutable.Option.FrozenSet` and `FSharp.Collections.Immutable.Tuple.FrozenSet` modules repeat
   `choose`, `tryGetValue` and `tryAlternateLookup` with options, and `partition` and `partitionWith` with reference tuples.
 * `frozenSet { }` builds a frozen set, and `FrozenSetCE` created with an equality comparer builds frozen sets that compare