Previously, pickling a Permutation whose base table lived in an
in-memory database raised ValueError because the worker had no way to
reopen it. Mirror what we already do for the in-memory permutation
table: serialize the base table to Arrow IPC stream bytes and rebuild
it as an in-memory LanceTable in __setstate__.

This adds dataset-sized cost to pickles of memory-backed permutations,
so users with large in-memory base tables should still prefer
persisting them or supplying a connection_factory. New test confirms
round-trip behavior for a memory-backed identity permutation.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

The lazy reader build introduced a sync `reader` property and a parallel
async `_reader_async()` to dodge a re-entrant `LOOP.run` deadlock when
the property was touched from inside a coroutine. The lazy path bought
nothing in practice — every `_clone()` rebuilt anyway because we never
shared `_reader` across clones — so the cost (two accessors, deadlock
trap, `_ = new_perm.reader` band-aids in with_skip/with_take, validation
deferred to first access) wasn't justified.

Switch to eager building:

- `__init__` accepts an optional `_reader=` kwarg; if absent it builds
  via `LOOP.run(_build_reader())`. `self.reader` is a plain attribute.
- `from_tables` passes the reader it already built via `_reader=` so
  there is no double build.
- `__setstate__` rebuilds eagerly after restoring tables.
- `_clone()` checks whether the overrides touch reader-affecting fields
  ({base_table, permutation_table, split, offset, limit}) — if not, it
  passes the existing `self.reader` through, so with_batch_size,
  _with_selection, with_transform, and with_connection_factory share
  the parent's reader instead of rebuilding.
- `_reader_async()` is gone; schema/iter/__getitems__ just
  `await self.reader.foo(...)` directly.
- with_skip/with_take drop their explicit `_ = new_perm.reader` since
  __init__ already builds eagerly.

Net -13 lines and the deadlock surface is removed. All 65 tests green.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

_clone was just sugar around the constructor. Replace it with
copy.copy(self) at each call site:

- Reader-preserving updates (with_batch_size, _with_selection,
  with_transform, with_connection_factory) just shallow-copy and
  mutate the one field. The reader is preserved automatically.
- Reader-rebuilding updates (with_skip, with_take) shallow-copy,
  mutate offset/limit, then explicitly reassign self.reader from a
  fresh _build_reader().

Removes the _READER_AFFECTING_FIELDS set and the field-list duplication
between __init__ and _clone. -14 net lines.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

The second example was using namespace_path on open_table(), which is
not what "namespace connection" means in lancedb. Replace it with a
proper lancedb.connect_namespace() usage that takes an implementation
name and a properties dict (e.g. "dir" with {"root": ...} or "rest"
with a URL), partial-bound so the worker rebuilds the same namespace
connection on unpickle.

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>