[vladwing]

The database inserters of the --git range, tree, --commits and lore pipelines hold a runtime worker while they wait for their next batch. They are tokio tasks that wait in a blocking std::sync::mpsc recv(), under a std Mutex all of them share. With --db-threads at or above the worker count, every worker but the one running an insert sits in recv() or in the mutex, and all of lance's async work for the run shares that one worker. On the default runtime that takes --db-threads at or above the CPU count. With the 32-worker cap in #112 it takes at most 32, so hosts with more CPUs reach it at --db-threads 32. How much slower such a run gets has not been measured.

Add recv_shared(), which runs the locked receive on tokio's blocking pool, and use it at all four sites. A waiting inserter now occupies a blocking-pool thread instead of a worker; the pool's default limit is 512 threads. recv_shared() uses spawn_blocking rather than block_in_place because block_in_place panics on the current-thread runtime that #[tokio::test] gives tests. Each site handles a poisoned receiver lock as before: the range, tree and --commits inserters panic, as their unwrap() did, and the lore inserter logs and leaves its loop. The tuple receive in git_range.rs that runs on a std thread is unchanged.

This conflicts with #113, which makes the lore inserter keep receiving until a batch holds batch_size emails. Whichever lands second resolves it by moving that loop into the closure, so the whole merge runs on the blocking pool:

recv_shared(&result_rx_clone, move |rx| {
    rx.recv().map(|mut emails| {
        while emails.len() < batch_size {
            match rx.recv() {
                Ok(more) => emails.extend(more),
                Err(_) => break,
            }
        }
        emails
    })
})

recv_shared_does_not_hold_workers parks two waiters on a live channel in a two-worker runtime and checks that a newly spawned task still runs. With the waiters calling lock().unwrap().recv() directly, the same test fails after its 10 s timeout.