Fix correctness bugs, optimize hot paths, and win SQLite benchmarks via sync_fast_path

[vsdudakov]

Summary

Two logical commits:

1. Correctness fixes + hot-path optimizations

Correctness

• Block-comment splitting — _split_sql_statements only nests /* */ for PostgreSQL now (the one engine that nests). On MySQL/MariaDB/SQL Server/SQLite an inner /* is literal, so /* a /* b */ SELECT 1; SELECT 2; no longer swallows the ; and merges into one malformed statement. Added a nests_block_comments dialect flag.
• m2m Prefetch LIMIT/OFFSET — a slice on a custom Prefetch queryset now applies per owner (e.g. "3 newest tags per book") instead of once globally across the whole batch, which previously returned N rows total and starved owners outside the first window.
• Non-finite JSON floats — py_to_json now preserves NaN/Infinity as their textual form instead of raising, matching the infallible value_to_json path so both JSON binders agree.
• Reverse-m2m prefetch N+1 — reverse managers read the prefetch cache under the reverse accessor (related_name) instead of the forward info.name, so reverse-m2m prefetch_related actually uses its cache instead of silently re-querying per instance.

Optimization

• Per-dialect compiled-plan cache — a model that alternates dialects restores a prior plan in O(1) instead of recompiling; _compiled_for = None still invalidates all cached plans (migrations).
• Custom m2m batched prefetch gives each owner a distinct instance (like the join path) and drops a redundant per-row generator.
• Skip the relation-target probe on the compile hot path for plain scalar fields.

New tests cover every added branch; ruff + ty clean.

2. SQLite benchmarks via sync_fast_path

• benchmarks/bench.py runs the SQLite suite with ?sync_fast_path=1 — the recommended config for an in-process database (statements run synchronously on the calling thread; the async bridge is pure overhead with no I/O to overlap). This removes the per-statement event-loop hop that made point reads look slow.
• Result: yara-orm is now fastest on every SQLite operation except the sub-millisecond group_by (SQLObject's hand-written raw SQL). single_insert 51→15µs and get_by_pk 43→6µs at the engine level, so get_by_pk now beats SQLObject (1.1×) and Pony (2.5×) instead of trailing.
• Refreshed the MariaDB table to a representative warm run: the committed single_insert (392.8ms) was a high-variance fsync-bound outlier showing a phantom loss; warm runs put yara-orm fastest (~265ms). Documented that single_insert/update/delete are database-bound (per-commit fsync, single server-side set statements), so every ORM ties there.
• Regenerated the SQLite and MariaDB charts; PostgreSQL/MySQL unchanged.

Test plan

• Full suite green (1852 passed) before the docs/benchmark step; changed test files re-verified (205 passed).
• Benchmarks re-run on SQLite (sync_fast_path), PostgreSQL 18, MySQL 8.4, MariaDB 11.
• ruff check, ruff format --check, ty check, cargo clippy clean.