## Summary

- make the Python `PackedBlobWriter` and `DedicatedBlobWriter` wrappers
safe to release on a thread other than the one that created them
- replace PyO3's `unsendable` restriction with mutex-protected writer
ownership
- add a production-shaped regression test covering both writer types

## Motivation

Geneva's Blob v2 checkpoint path prepares packed blob sidecars on a
dedicated checkpoint-writer thread. During a large Azure benchmark,
Azure returned `503 ServerBusy` from a multipart block `PUT`. The
checkpoint thread propagated that object-store exception to the actor's
owner thread.

The original exception retained its Python traceback. That traceback
retained the checkpoint frame and its local `PackedBlobWriter`, so the
last reference to the writer was eventually released by the owner thread
rather than the checkpoint thread. Because the binding declared the
writer as `#[pyclass(unsendable)]`, PyO3 emitted a second unraisable
exception:

```text
RuntimeError: lance::blob::PyPackedBlobWriter is unsendable, but is being dropped on another thread
```

This secondary error appeared at unrelated Python stack locations,
obscured the original Azure failure, and prevented normal RAII cleanup
of the writer on that path. The same ownership problem applies to
`DedicatedBlobWriter`, which used the same binding policy.

## Root cause

The core Rust blob writers are `Send`, so transferring ownership for
destruction is safe. They are not `Sync`, however, because the
underlying `dyn Writer` is not shareable for concurrent access. PyO3
0.28 requires ordinary Python classes to be both `Send` and `Sync`;
simply removing `unsendable` therefore does not compile.

## Fix

Store each core writer as `Mutex<Option<Writer>>` and remove the
`unsendable` annotation. The mutex makes the Python wrapper `Send +
Sync` while retaining exclusive access to the non-`Sync` writer.
Existing mutation and finish semantics remain unchanged:

- completed writers still raise the existing `ValueError`
- writer ownership is still consumed by `finish`
- failed bulk writes still drop their active writer through RAII
- a poisoned lock surfaces as a descriptive Python `RuntimeError`

There is no public Python API change.

## Regression coverage

The new parameterized test models the production lifetime directly:

1. create a packed or dedicated writer on a worker thread
2. raise and hand an exception containing that thread's traceback to the
owner thread
3. release the exception and force garbage collection on the owner
thread
4. assert that `sys.unraisablehook` receives no cross-thread destruction
error

The test fails on `main` with the same `PyPackedBlobWriter is
unsendable` / `PyDedicatedBlobWriter is unsendable` messages and passes
with this change.

## Validation

- `uv run make build`
- `uv run pytest -q python/tests/test_blob.py -k 'packed_blob_writer or
failed_blob_writer'` — 32 passed
- `uv run pytest -q python/tests/test_blob.py` — 139 passed
- `uv run make lint` — Ruff, Pyright (0 errors), Rust formatting, and
Clippy passed
- commit hooks — Ruff, Ruff format, Rust formatting, and typos passed

(cherry picked from commit 4f86078)