feat: QuerySet::iterator(chunk_size) — chunked streaming (closes #23)

[ujeenet]

Summary

Closes #23. Django parity for QuerySet.iterator(chunk_size=2000). Returns a ChunkedIter<T> that fetches chunk_size rows at a time via LIMIT N OFFSET M — never buffers the full result set. Right tool for million-row exports / ETL pipelines / batch processors that would OOM with fetch_pool returning Vec<T>.

```rust
let mut iter = Post::objects()
.where_(Post::published.eq(true))
.order_by(&[("id", false)])
.iterator(2_000)?;

// 1. Whole-chunk loop:
while let Some(chunk) = iter.next_chunk(&pool).await? {
for post in chunk { /* … */ }
}

// 2. Row-by-row loop (internal VecDeque buffer, O(1) per row):
let mut iter = Post::objects().order_by(&[("id", false)]).iterator(2_000)?;
while let Some(post) = iter.next_row(&pool).await? { /* … */ }
```

API

Method	Returns	Description
QuerySet::iterator(chunk_size)	Result<ChunkedIter<T>>	Compiles eagerly — schema errors surface here, not mid-stream
ChunkedIter::next_chunk(&pool)	Result<Option<Vec<T>>>	Whole-chunk; None = done
ChunkedIter::next_row(&pool)	Result<Option<T>>	Row-by-row; buffers one chunk internally
ChunkedIter::rows_seen()	i64	Cumulative count (progress reporting)
ChunkedIter::is_exhausted()	bool	Post-drain flag

Mixing next_chunk and next_row on the same iterator is safe — the buffer drains in row order before any new DB fetch.

Design notes

• LIMIT/OFFSET chunker, not a server-side cursor. Portable across PG / MySQL / SQLite with no transaction overhead. Trade-off documented in the cookbook: O(n²) total work on deep pagination (each chunk reseeks). For truly streaming PG reads, drop into transaction() + raw sqlx::query(...).fetch Stream directly.
• VecDeque buffer for row-by-row path. O(1) pop_front per row; a Vec::remove(0) would be O(n).
• Exhaustion is sticky. Once a chunk comes back smaller than chunk_size (or empty), the iterator marks itself exhausted and every subsequent call returns Ok(None) without re-querying.
• No new dependencies. Considered exposing a Stream impl via futures-core but went with the simpler next_chunk / next_row async-method API — zero new deps, two ergonomic styles, no Pin/Unpin gymnastics in user code.

Tri-dialect

Works on every backend — LIMIT/OFFSET is the portable common denominator. Cookbook flags the deep-pagination trade-off + the PG escape hatch.

What landed

• `src/sql/executor.rs` — `ChunkedIter` struct + `QuerySet::iterator(chunk_size)` + 4 methods on `ChunkedIter`.
• `tests/iterator_live.rs` — 5 live PG tests against a 1000-row fixture.
• `docs/orm.md` — cookbook section under "Row-level locks".

Tests

Suite	Count	Status
`tests/iterator_live.rs` (live PG, 1000-row fixture)	5	passing
`cargo test -p rustango --features tenancy,mysql,sqlite --tests` (full suite)	all	passing

Live tests cover:

• next_chunk_yields_all_rows_in_order — 5 chunks of 200, row order preserved.
• next_row_yields_every_row_with_internal_buffering — chunk_size that doesn't divide evenly (150 → 7 chunks: 6×150 + 100).
• mixed_next_row_and_next_chunk_preserve_order — partial drain via next_row, then next_chunk yields buffered remainder before refetching.
• iterator_respects_where_clause_and_short_final_chunk — narrowed filter, short final chunk (4 chunks: 30, 30, 30, 10).
• empty_result_yields_none_first_call — no DB hit on subsequent calls after exhaustion.

Verification

```
cargo test -p rustango --features tenancy,mysql,sqlite --tests → all passing
DATABASE_URL=... cargo test --features tenancy --test iterator_live → 5 passed
cargo test --workspace --all-features --no-run → clean
cargo build --no-default-features --features sqlite,tenancy → clean
```

Test plan

• 1000-row fixture iterated chunk-by-chunk in order.
• 1000-row fixture iterated row-by-row in order.
• Mixed next_chunk + next_row preserves order.
• WHERE filter respected.
• Short final chunk.
• Empty result short-circuits.
• rows_seen() tracks correctly across both paths.
• is_exhausted() becomes true once drained.
• Workspace --all-features --no-run gate passes.
• SQLite-tenancy litmus build passes.
• CI green on `postgres_test` + `mysql_live` + `sqlite_live` + `sqlite_litmus`.