fixup! docs: HashSet and ISet in the changelog and the collection table

The published 1.0.0 package has only the type abbreviations `ISet<'T>`, `SortedSet<'T>` and
`HashSet<'T>` for the sets: no `HashSet` or `SortedSet` module, no `HashSetBuilder<'T>`
abbreviation (checked in the metadata and the signature data of both target frameworks, and
`sets.fs` of the `v1.0.0` tag agrees). The `Changed` and `Removed` entries name only what
1.0.0 had or did, so:

- `Removed` keeps the `ISet<'T>` abbreviation. The entries for the `HashSetBuilder<'T>`
  abbreviation and for `where`, `pick`, `tryPick`, `vTryPick`, `check`, `ofComparer`,
  `ofSeqWithComparer`, `builderWithComparer` and `builderWith` go: they were names of the
  unreleased `HashSet` module of `main`.
- The eight `HashSet` entries of `Changed` go (`difference` and `union`, the functions that
  took a sequence, the order of the elements that stay, the compiled name of the module,
  `length` and `keyComparer`, `filter` and the set algebra, `tryGetValue`, `unionMany` and the
  null checks): they compared the module with `main`.
- What the dropped entries said about the new module and is still true moves to `Added`: which
  functions keep the comparer, the null checks, `unionMany` of nothing, the `voption` and
  struct tuple results, the BCL members that take a sequence, and which equal element stays.

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

Author: xperiandri

CHANGELOG.md

@@ -47,6 +47,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   the result tells whether `Add` changed anything, as the `bool` result of `Builder.Add` does. Hash sets have no builder
   module: `builder`, `toBuilder` and `ofBuilder` are `CreateBuilder`, `ToBuilder` and `ToImmutable`, and the builder is
   used directly.
+* `add`, `addRange`, `remove`, `removeRange`, `clear`, `update`, `filter` and `partition` of `HashSet` keep the comparer
+  of their input, and the set algebra keeps the comparer of the first hash set; `map`, `choose` and `partitionWith`
+  compare with the default comparer of the result type. Every function throws `ArgumentNullException` for a `null` hash
+  set, sequence or array. `unionMany` of an empty sequence returns an empty hash set, as `Set.unionMany` does.
+  `tryGetValue` returns a `voption`, `choose` takes a function that returns a `voption`, and `partition` and
+  `partitionWith` return struct tuples.
+* The set algebra and the relations of `HashSet` take hash sets, as the `Set` functions do. The BCL members that take a
+  sequence map as follows: `Union` and `Except` are `addRange` and `removeRange`, `Overlaps` and `IsSupersetOf` are
+  `Seq.exists` and `Seq.forall` with `contains`, and the others take `HashSet.ofSeq elements`, or
+  `(HashSet.forComparer (HashSet.comparer set)).ofSeq elements` to give the elements the comparer of the first hash set.
+* The element that stays when the comparer finds two elements equal follows the BCL: `union` and `addRange` keep the
+  element of the first hash set, `intersect` keeps the elements of the second one, and the creation functions keep the
+  first element of their input. `isProperSuperset` is the exception: it counts the elements of the second hash set that
+  the comparer of the first one finds equal once, as the documentation of `IsProperSupersetOf` says, where the member
+  counts each of them.
 * The `ISet` module works on any `IImmutableSet<'T>` with the functions of `HashSet` that need neither a creation nor a
   comparer, `addRange` and `removeRange` included; the transformations that keep the element type return the
   implementation of their input.
@@ -69,29 +84,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * `FlatList.sub` has the meaning of `Array.sub`: `sub array startIndex count` returns `count` elements from `startIndex`.
   It was `sub start stop list`.
 * The nested `FlatList.Builder` module is now the `FlatListBuilder` module.
-* `HashSet`: `difference set1 set2` returns the elements of `set1` that are not in `set2`, as `Set.difference` does. In
-  1.0.0 `difference values set` removed a sequence from a hash set: that is `removeRange values set` now, with the same
-  order of the arguments. `union set values` of 1.0.0 is `addRange values set`.
-* `HashSet`: `union`, `intersect`, `isSubset`, `isProperSubset`, `isSuperset` and `isProperSuperset` took a sequence as
-  the second argument in 1.0.0 and take a hash set now, as the `Set` functions do: pass `HashSet.ofSeq elements`, or
-  `(HashSet.forComparer (HashSet.comparer set)).ofSeq elements` to give the elements the comparer of the first hash
-  set. The BCL members that take a sequence map the same way: `Union` and `Except` are `addRange` and `removeRange`,
-  `Overlaps` and `IsSupersetOf` are `Seq.exists` and `Seq.forall` with `contains`, and the others take `ofSeq` of the
-  sequence.
-* `HashSet`: the element that stays when the comparer finds two elements equal follows the BCL: `union` and `addRange`
-  keep the element of the first hash set, `intersect` keeps the elements of the second one, and the creation functions
-  keep the first element of their input. `isProperSuperset` counts the elements of the second hash set that the
-  comparer of the first one finds equal once, where `ImmutableHashSet.IsProperSupersetOf` counts each of them, against
-  its documentation.
-* `HashSet`: the compiled name of the module is `HashSet`, which C# callers see; it was `ImmutableHashSetModule`.
-* `HashSet`: `length` is renamed to `count` and `keyComparer` to `comparer`.
-* `HashSet`: `filter`, `partition` and the set algebra keep the comparer of their input, the set algebra that of the first
-  set; `map`, `choose` and `partitionWith` compare with the default comparer of the result type. `filter` dropped the
-  comparer before.
-* `HashSet`: `tryGetValue` returns `voption`, `choose` takes a function that returns `voption`, and `partition` and
-  `partitionWith` return struct tuples.
-* `HashSet`: `unionMany` of an empty sequence returns an empty hash set, as `Set.unionMany` does, and every function throws
-  `ArgumentNullException` for a `null` hash set, sequence or array.
 
 ### Removed
 
@@ -111,14 +103,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * `FlatList.removeRange`: use `removeManyAt`.
 * The `ISet<'T>` abbreviation of `IImmutableSet<'T>`, because it shadowed `System.Collections.Generic.ISet<'T>`: use
   `IImmutableSet<'T>` and the `ISet` module.
-* The `HashSetBuilder<'T>` abbreviation: use `HashSet<'T>.Builder`.
-* `HashSet.where`: use `filter`. `HashSet.pick`, `tryPick` and `vTryPick`, which the FSharp.Core `Set` module does not
-  have: use `HashSet.toSeq set |> Seq.pick chooser`, or `Seq.tryPick` and `ValueOption.ofOption`. The public
-  `HashSet.check`.
-* `HashSet.ofComparer comparer`, `ofSeqWithComparer comparer elements` and `builderWithComparer comparer`: use
-  `(HashSet.forComparer comparer).empty`, `(HashSet.forComparer comparer).ofSeq elements` and
-  `(HashSet.forComparer comparer).builder ()`. `HashSet.builderWith`, whose argument bound to the comparer overload of
-  the BCL member, has no replacement: hash sets have no capacity.
 
 ## [1.0.0] - 2020-02-23