fixup! docs: Stack and IStack in the changelog and the collection table

The `Changed` and `Removed` entries name only what the published 1.0.0 had or did, checked in the
1.0.0 assembly: its `Stack` module has `cons`, `empty`, `head`, `ofArray`, `ofSeq`, `peek`, `pop`,
`push`, `tail` and the complete active pattern `Cons | Nil`.

- `Removed` keeps `push`, `peek` and `pop`, with their replacements, and says that `pop` returned
  a reference tuple. The `ImmutableStack` module alias goes: an abbreviation of a module cannot be
  used from another assembly.
- `Changed` compares with 1.0.0. `ofSeq` and `ofArray` put the first element on top where they put
  the last one. `cons`, `head` and `tail` take and return `ImmutableStack<'T>` where they took and
  returned `IImmutableStack<'T>`, and compile to `Push`, `Peek` and `Pop`. `head` and `tail` of an
  empty stack throw `ArgumentException` where they threw `InvalidOperationException`. A `null` stack
  threw `ArgumentNullException` in 1.0.0 too, so that is no longer listed, and neither are `uncons`,
  `ofList`, `toList`, `rev` and the transformations, which 1.0.0 did not have.
- `Added` no longer names the patterns `Cons` and `Nil`, which 1.0.0 had as one complete pattern,
  nor `cons`, `head` and `tail` in the sentence about compiled names.

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

Author: xperiandri

CHANGELOG.md

@@ -56,10 +56,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   value that no element equals, as the builder of an indexed list does.
 * `Stack` has every function of the FSharp.Core `List` module that applies to an immutable stack, with its semantics and
   exceptions and with stable sorts, plus `consMany`, `ofReadOnlySpan`, `ofSpan`, `skipLast`, `sortWithComparer`,
-  `takeLast`, `tryTail`, `tryUncons`, `uncons` and the struct partial active patterns `Cons` and `Nil`. Its functions name
-  their stacks `stack`, `stack1` and `stacks` where `List` names its lists, and the exceptions report these names. `cons`,
-  `consMany`, `head`, `tail` and `uncons` compile to `Push`, `PushMany`, `Peek`, `Pop` and `PeekPop`, and `tryHead`,
-  `tryTail` and `tryUncons` to `TryPeek`, `TryPop` and `TryPeekPop`, in the `IStack`, `Option` and `Tuple` modules too.
+  `takeLast`, `tryTail`, `tryUncons` and `uncons`. A stack enumerates its elements from the top, and every function
+  treats it as a list in that order; `rev` puts the last element on top. Its functions name their stacks `stack`,
+  `stack1` and `stacks` where `List` names its lists, and the exceptions report these names. `consMany`, `uncons`,
+  `tryHead`, `tryTail` and `tryUncons` compile to `PushMany`, `PeekPop`, `TryPeek`, `TryPop` and `TryPeekPop`, in the
+  `IStack`, `Option` and `Tuple` modules too.
 * The `IStack` module has the functions of `Stack` for `IImmutableStack<'T>`, without the creation functions, plus
   `clear`. Its functions keep the implementation of the input stack where the result has the element type of the input,
   and return a `Stack` otherwise. `append` pushes the first stack onto the second one, which receives the elements, so
@@ -122,16 +123,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * `IndexedList.rev` builds the reversed list from a reversed copy of the elements. At 100 000 integers it takes about 3 ms
   where `reverse`, which called `ImmutableList.Reverse`, took about 23 ms, and it allocates 5.2 MB where `reverse`
   allocated 4.8 MB.
-* `Stack`: a stack enumerates its elements from the top, and every function treats it as a list in that order. `ofSeq`,
-  `ofList` and `ofArray` put the first element on top, so that `ofSeq` is the inverse of `toList`, while `ofSeq` and
-  `ofArray` wrapped `ImmutableStack.CreateRange`, which puts the last element on top. The transformations keep the order,
-  and `rev` reverses it.
-* `Stack`: the functions take and return `ImmutableStack<'T>` instead of `IImmutableStack<'T>`; the functions for the
-  interface are in the `IStack` module.
-* `Stack`: `head`, `tail` and `uncons` of an empty stack throw the `ArgumentException` of `List.head` and `List.tail`
-  instead of the `InvalidOperationException` of `ImmutableStack`, and a `null` stack throws `ArgumentNullException`.
-* `Stack`: the complete active pattern `Cons | Nil` is replaced by the struct partial active patterns `Cons`, which matches
-  a struct tuple, and `Nil`.
+* `Stack`: `ofSeq` and `ofArray` put the first element on top, so that the stack enumerates the elements in the order of
+  the input. They wrapped `ImmutableStack.CreateRange`, which puts the last element on top.
+* `Stack`: `cons`, `head` and `tail` take and return `ImmutableStack<'T>`, where they took and returned
+  `IImmutableStack<'T>`; the `IStack` module has them for the interface. They compile to `Push`, `Peek` and `Pop`, where
+  1.0.0 compiled them under their F# names.
+* `Stack`: `head` and `tail` of an empty stack throw the `ArgumentException` of `List.head` and `List.tail`, where they
+  threw the `InvalidOperationException` of `ImmutableStack`.
+* `Stack`: the complete active pattern `Cons | Nil`, which matched a reference tuple, is replaced by the struct partial
+  active patterns `Cons`, which matches a struct tuple, and `Nil`.
 
 ### Removed
 
@@ -169,8 +169,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * The `IndexedSeq` module and the `IIndexedSeq<'T>` abbreviation of `IReadOnlyList<'T>`: use `IReadOnlyList<'T>`, whose
   `Count` and indexer replace `IndexedSeq.length` and `IndexedSeq.item`. `IndexedSeq.check` needs no replacement, because
   every function of the list modules throws `ArgumentNullException` for a `null` list.
-* `Stack.push`, `peek` and `pop`: use `cons`, `head` and `uncons`.
-* The `ImmutableStack` module alias of `Stack`.
+* `Stack.push`, `peek` and `pop`: use `cons`, `head` and `uncons`. `pop` returned the top and the stack below it as a
+  reference tuple; `uncons` returns a struct tuple.
 
 ## [1.0.0] - 2020-02-23