int_proxy join: draw the proxy collection lazily, a block at a time

[frankmcsherry]

The proxy join performed the whole of a unit's work inside prep, and returned an iterator that spilled the finished containers.
The driver's fuel budget was therefore spent after the fact.

The backend interface

present0/present1 are replaced by a single advance:

fn advance(
    &mut self,
    instance: &JoinInstance<B0, B1>,
    from: &mut Option<u64>,
    bridge0: &mut ProxyBridge<B0::Time, Self::R0>,
    bridge1: &mut ProxyBridge<B0::Time, Self::R1>,
);

It populates both bridges with the intersecting keys from from onward and updates from.
This removes the two-phase presentation, in which the whole fresh side was materialized to derive the key filter for the other side.

A unit's progress through the key space rides in from rather than in the backend, so the harness can interleave the calls of the many units it has in flight.
A key hash must be reported entirely by the call that first mentions it.

cross populates a Vec<Self::Output> rather than returning one container, and takes its times and diffs by &mut Vec<_> so the harness keeps the allocations.
Both granularities are the backend's: advance sizes the block it draws, cross the containers it cuts.
The operator's own JOIN_CHUNK policy is gone, along with the mid-key flushing it needed; the operator draws a block, merge-matches it whole, and hands the matches back.
A single key's matches are held whole, as under the cursor tactic.

JoinInstance owns its batches, which drops its lifetime parameter and lets the iterator hold it as a single field.

Checking

Debug assertions enforce the advance contract: bridges sorted and consolidated, from strictly increasing or exhausted, and each reported key hash confined to the block that first mentions it.
The last guards the case that would otherwise be silently wrong rather than a panic, and the from check also guards liveness.

Nothing implements ProxyJoinBackend, here or elsewhere, so this is compile-checked only, as the framework was before.
A reference backend and a test asserting that the block-wise result matches the single-block result would be the natural follow-on.

Known gaps

Two questions this leaves open, both about what a backend can rely on:

• The trait says the harness "interleaves their calls freely", but the code guarantees more: advance and the cross consuming its block are adjacent within one next(), and no other unit can interpose. That adjacency is what makes ephemeral per-block value_id assignment workable, and the doc currently reads as forbidding it.
• There is no per-unit identity and no completion signal, so a backend cannot cache a cursor across the blocks of one unit, and gets no hook when the driver drops an unfinished iterator. ProxyReduceBackend's begin/next_window/finish session provides both.

🤖 Generated with Claude Code

https://claude.ai/code/session_01ErrnMtBsvrvncVeYL51TMv