Add parameterized FromRow methods (fetch_one_as/fetch_all_as/stream_as + ToSqlParam params)

[StefanSteiner]

Summary

There is no method that combines FromRow struct-mapping with
ToSqlParam parameter binding in a single call. Today you can have one or
the other, but not both — so a parameterized query whose results you want as a
struct requires dropping to the raw Row API and mapping by hand.

Current state

Struct-mapping methods take a plain &str (no params):

• fetch_one_as<T: FromRow>(&self, query: &str) — connection.rs:742 / async_connection.rs:359
• fetch_all_as<T: FromRow>(&self, query: &str) — connection.rs:775 / async_connection.rs:375
• stream_as<T: FromRow>(&self, query: &str) — connection.rs:840 / async_connection.rs:435

Parameter-binding methods return raw rows (no FromRow):

• query_params(&self, query, params: &[&dyn ToSqlParam]) → Rowset — connection.rs:1036 / async_connection.rs:574
• command_params(...) → affected-row count — connection.rs:1089 / async_connection.rs:608

So SELECT * FROM users WHERE org_id = $1 → Vec<User> isn't expressible in
one call. The workaround is query_params(...) then a manual
RowAccessor/row.get() loop — which defeats the ergonomics FromRow exists
to provide, and is exactly the pattern users reach for now that #65 broadened
ToSqlParam coverage (Numeric/Interval/JSON).

Proposed work

Add parameterized *_as variants mirroring the existing trio, on both the sync
Connection and the async AsyncConnection:

• fetch_one_as_params<T: FromRow>(&self, query: &str, params: &[&dyn ToSqlParam]) -> Result<T>
• fetch_all_as_params<T: FromRow>(&self, query: &str, params: &[&dyn ToSqlParam]) -> Result<Vec<T>>
• stream_as_params<T: FromRow>(&self, query: &str, params: &[&dyn ToSqlParam]) -> Result<impl Iterator<Item = Result<T>>>
  (async: Stream)

Implementation should be small: reuse the existing extended-query path
(prepare_typed + binary bind from query_params) to get the Rowset, then
feed each row through RowAccessor + T::from_row exactly as the current
*_as methods already do. The two halves already exist; this is plumbing them
together, not new protocol work.

Naming is open (_as_params vs _params_as vs an options struct) — pick what
reads best against the existing query_params / fetch_*_as names.

Acceptance criteria

• Sync + async variants for fetch_one / fetch_all / stream.
• Round-trip test: parameterized SELECT bound with a ToSqlParam value,
  mapped into a #[derive(FromRow)] struct, asserting the values.
• Docs/examples updated; the FromRow and ToSqlParam module docs
  cross-reference the new methods.

Context

Surfaced while reviewing FromRow coverage after #65. The mapping layer
(FromRow + #[derive(FromRow)]) and the binding layer (ToSqlParam) are
both complete individually; this is the missing intersection.

[StefanSteiner]

Examples — what these methods would provide

Before (today): parameterized query → struct requires manual mapping

use hyperdb_api::{Connection, FromRow, ToSqlParam};

#[derive(FromRow)]
struct User {
    id: i32,
    name: String,
    org_id: i32,
}

// You can bind params (query_params) OR map to a struct (fetch_all_as),
// but not both — so you drop to the raw Row API and map by hand:
let rows = conn
    .query_params(
        "SELECT id, name, org_id FROM users WHERE org_id = $1",
        &[&42i32],
    )?
    .collect_rows()?;

let users: Vec<User> = rows
    .iter()
    .map(|r| Ok(User {
        id: r.get(0).ok_or_else(|| /* ... */)?,
        name: r.get(1).ok_or_else(|| /* ... */)?,
        org_id: r.get(2).ok_or_else(|| /* ... */)?,
    }))
    .collect::<Result<_>>()?;

After: one call, mapped + bound

// fetch_all_as_params — bind a param AND map into the struct
let users: Vec<User> = conn.fetch_all_as_params(
    "SELECT id, name, org_id FROM users WHERE org_id = $1",
    &[&42i32],
)?;

// fetch_one_as_params — single row (errors if 0 or >1)
let user: User = conn.fetch_one_as_params(
    "SELECT id, name, org_id FROM users WHERE id = $1",
    &[&7i32],
)?;

// stream_as_params — constant-memory streaming with bound params
for user in conn.stream_as_params::<User>(
    "SELECT id, name, org_id FROM users WHERE org_id = $1",
    &[&42i32],
)? {
    let user = user?;
    // ... process one row at a time, no full Vec in memory
}

Multiple params of mixed types (leverages the #65 ToSqlParam work)

use hyperdb_api_core::types::Interval;

let recent_big: Vec<Order> = conn.fetch_all_as_params(
    "SELECT * FROM orders WHERE amount > $1 AND age < $2",
    &[&100.0_f64, &Interval::new(0, 7, 0)], // $1 f64, $2 INTERVAL '7 days'
)?;

Async — same shape, awaited

let users: Vec<User> = conn.fetch_all_as_params(
    "SELECT id, name, org_id FROM users WHERE org_id = $1",
    &[&42i32],
).await?;

// stream_as_params yields a Stream
use futures::StreamExt;
let mut stream = conn.stream_as_params::<User>(
    "SELECT * FROM users WHERE org_id = $1",
    &[&42i32],
)?;
while let Some(user) = stream.next().await {
    let user = user?;
    // ...
}

This collapses the bind + map round-trip into the same one-liner ergonomics
fetch_all_as already gives for non-parameterized queries.