A 250-chunk file used to show "file.md" frozen for 10+ seconds because
``_index_file`` awaited the embedder's full ``embed_texts`` before any
SSE event escaped. The per-file ``progress`` event landed all-or-nothing
even though all four embedder backends process chunks in batches.

Now each backend (OpenAI, Ollama, ONNX) calls an optional
``on_progress(done, total)`` after every batch completes, the engine
forwards those ticks through a per-file ``asyncio.Queue`` into the
existing ``index_path_stream`` generator as ``chunk_progress`` events,
and the web Index tab surfaces them as ``file.md — 100/250 chunks``.
The ONNX backend, previously a single ``to_thread(all_texts)`` call,
now loops batch-by-batch using the existing ``EmbeddingConfig.batch_size``
so the default local backend gets visibility too.

Why ``asyncio.Queue`` and not a buffered list: a buffer would serialize
all ticks until the file completes — defeating the point. The queue
forwards events in real time while the engine still waits on the inner
task to surface ``_index_file``'s exception, preserving the #590
``complete.errors`` contract. ``BaseException`` catch + ``task.cancel()``
in the consumer-abandon path stops embedding work past SSE response
lifetime (no leaked OpenAI requests on client disconnect).

The new ``EmbeddingConfig.progress_threshold`` (default 32, runtime-
mutable) gates emission so small files stay quiet; setting it to 0 is
an explicit "always emit" debug affordance. JS throttles ``chunk_progress``
DOM writes to 100 ms gaps but lets the final tick (``done == total``)
through unconditionally — otherwise the user would see "(192/250)" right
before the next file's name pops in (subtle jank, cheap to fix).

Tests:
- ``test_embedding_progress.py`` (new): per-backend monotonic + end-at-
  total + raise-swallow contract; one test per backend pinning the
  expected per-batch call count.
- ``test_indexing_engine.py`` (appended): event flow above threshold,
  ordering invariant (chunk_progress yields before that file's progress),
  no emission below threshold, threshold=0 emits anywhere, embedding
  failure still surfaces in ``complete.errors`` (#590 guard), consumer
  ``aclose()`` cancels in-flight embedding and decrements ``_active_runs``.

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

Wall-clock benchmark on 250 mixed-length texts caught a +20% regression
introduced by the per-batch-loop refactor:

  variant A: model.embed(texts)               default bs=256: 0.901s  ← old
  variant B: model.embed(texts, batch_size=64) explicit bs=64: 1.082s
  variant C: for batch in batches: model.embed(batch) bs=64:  1.099s  ← previous fix
  variant D: for vec in model.embed(texts):   stream:         0.922s  ← this commit

The cost was the number of ORT session.run invocations (4 vs 1), not
Python overhead. fastembed already batches internally at its default
batch_size=256; forcing 64 (whether via Python chunking or the
batch_size kwarg) doubled to quadrupled per-call setup cost.

Switch ONNX to a single ``model.embed(texts)`` call and stream-iterate
the resulting generator inside ``_embed_sync``, firing ``on_progress``
per yielded vector. Since ``_embed_sync`` runs in a worker thread,
``embed_texts`` wraps the callback with ``loop.call_soon_threadsafe``
and throttles to ~20 ticks per file (``total // 20``), with the final
tick (``done == total``) always emitted to honor the SSE consumer's
"(N/N)" final-render contract.

Re-bench after the fix: +1.69% wall-clock vs no-progress fast path,
21 ticks per 250-text run. Well under the 5% SLO from the PR test plan.

Also closes a subtle thread-safety hole: the previous implementation
fired ``on_progress`` (often ``queue.put_nowait`` into the SSE event
queue) directly from the worker thread, which happened to work because
asyncio.Queue ignores the lack of cross-thread guarantees on
``put_nowait`` but isn't documented to. ``call_soon_threadsafe``
makes that contract explicit.

Test changes:
- ``test_onnx_streams_progress_per_yield`` (new): per-yield contract.
- ``test_onnx_throttles_thread_hops_for_large_input`` (new): 200 texts
  → ~20 ticks (not 200), final tick == (n, n).
- ``test_onnx_no_progress_skips_callback_plumbing`` (new): fast path
  pins ``on_progress=None`` reaching ``_embed_sync`` so a future
  refactor doesn't always pay the ``call_soon_threadsafe`` cost.
- ``test_onnx_numerical_parity_*``: replaced "across batch_size" probe
  (now meaningless — single ORT call regardless) with "with vs without
  progress" parity, asserting bit-exact equality between fast path and
  streaming path. Tightened tolerance to rtol=1e-7 since both paths
  call the same underlying iterator in the same order.
- ``test_onnx_fires_progress_per_batch`` and ``test_onnx_single_batch_*``
  removed: ``config.batch_size`` no longer drives ONNX progress
  granularity.

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