Type the 14 operation factories precisely so reify can carry the result type.

- reify is now reify<S extends CollectionImpl<unknown, unknown>>(iter, seq): S —
  it follows the type of `seq`. The precision therefore lives in each factory's
  return type: same-kind factories (reverse/slice/sort/filter/skipWhile/
  takeWhile/interpose) are <C extends CollectionImpl<...>>(collection: C, …): C,
  while transforming factories return the precise transformed type
  (mapFactory → CollectionImpl<K, M>, flipFactory → KeyedCollectionImpl<V, K>, …).
- As a result `map` and `flip` in Collection.ts are clean single signatures
  again (no `): unknown` implementation overload needed).
- makeSequence / collectionClass are overloaded per collection kind.

The factory bodies build a sequence by dynamically mutating the makeSequence
result and drive the input through its dynamic iteration protocol (the
`IteratorType` union, unknown keys/values). That construction is not expressible
in the type system, so casts are confined to that boundary: a `loose()` view of
the input, the `MutableSequence` shape of the built sequence, and the return.
No `any` anywhere; the exported signatures are fully precise.

`interleave` keeps an overload + loose implementation since its result flows
through `flatten` (which widens to CollectionImpl<unknown, unknown>).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Add a public `__iterator(type: IteratorType, reverse?): IterableIterator<K | V | [K, V]>`
overload on CollectionImpl (promoting the existing implementation signature).
Operation factories forward a runtime `type` to `__iterator`, which previously
matched none of the literal overloads and forced a loose `unknown`-typed view of
the input.

With it, the `__iteratorUncached` bodies now iterate through the precisely-typed
`collection` directly: literal `ITERATE_ENTRIES` calls yield `[K, V]` steps, so
the per-element `entry[0] as K` / `entry[1] as V` / `value as V` / `key as K`
casts are gone. `loose()` is now only used for `get`/`has`/`includes`/`reverse`/
`flip` (which take `unknown` keys / non-base members), and `LooseInput` no longer
declares `__iterator`.

A few structural iterator-boundary casts remain because `collection.__iterator`
returns a native `IterableIterator` (immutable's `Iterator` class type is frozen)
and a `step` object is reused across output types. Those, the
`makeSequence`/return construction boundary, and the `unknown`-key `get`/`has`
will only fully clear up once the operation sequences become real typed classes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

…uence.js migration to TS