Rust V4→V5 API Migration Guide

I need help migrating a Ditto Rust application from v4 to v5. Focus on these critical changes:

TOOLCHAIN:
dittolive-ditto v5 requires rustc 1.91 or later. Add a rust-toolchain.toml to the
project root so the correct toolchain is selected automatically:
  [toolchain]
  channel = "1.91"

INITIALIZATION:
Replace Ditto::builder()...build() with Ditto::open(config).
- Create DittoConfig::new(database_id, connect) — NOT a builder pattern
- OnlinePlayground → DittoConfigConnect::Server { url: "https://...".parse().unwrap() }. Copy the URL from the Ditto Portal (Connect via SDK → **URL**) as-is — don't build it from the database ID.
- OfflinePlayground → DittoConfigConnect::SmallPeersOnly { private_key: None }
- SharedKey → DittoConfigConnect::SmallPeersOnly { private_key: Some(key_bytes) }
- Manual → No v5 equivalent
- Ditto::open(config) is async (returns Result<Ditto, DittoError>)
- Ditto::open_sync(config) is the blocking alternative
- URL fields use url::Url type, not String — parse with .parse().unwrap()
- Remove update_transport_config — v5 automatically configures the websocket URL from the Server connect URL
- Remove disable_sync_with_v3 and DQL strict mode workarounds
- IMPORTANT: If v4 app used default (strict=true), set DQL_STRICT_MODE=true BEFORE starting sync

AUTHENTICATION:
- ditto.auth() returns Option<DittoAuthenticator> — None in SmallPeersOnly mode
- set_expiration_handler requires a value implementing DittoAuthExpirationHandler
- RECOMMENDED: Implement DittoAuthExpirationHandler on a struct that holds captured state (token, config)
  - on_expiration is a plain async fn taking &self — clone fields inside the method body as needed
  - Do NOT write fn on_expiration(...) -> impl Send + Future<Output = ()> — use async fn directly
- auth.login(token, provider) is SYNCHRONOUS — returns Result<AuthenticationClientFeedback, DittoError>
- Use get_development_provider() for playground tokens (NOT "__playgroundProvider")
- Handler called when duration_remaining == Duration::ZERO (initial) or > 0 (refresh)

IMPORTS:
DittoAuthExpirationHandler, DittoConfig, and DittoConfigConnect are NOT in submodules.
They are re-exported directly from the crate root. Do NOT write dittolive_ditto::auth::
or dittolive_ditto::config:: — those modules do not exist in v5.
- Correct: use dittolive_ditto::{DittoAuthExpirationHandler, DittoConfig, DittoConfigConnect, DatabaseId, Ditto};
- Correct: use dittolive_ditto::identity::get_development_provider;
- Do NOT add `use std::future::Future` — the trait method is async fn, no manual Future type needed

SYNC:
- ditto.start_sync() → ditto.sync().start()
- ditto.stop_sync() → ditto.sync().stop()
- ditto.is_sync_active() → ditto.sync().is_active()

STORE ACCESS:
- ditto.store() is a method (with parentheses), not a field
- store.execute_v2() → store.execute() — uses IntoQuery trait
- store.register_observer_v2() → store.register_observer()
- store.register_observer_with_signal_next_v2() → store.register_observer_with_signal_next()
- For parameterized queries: store().execute(("SELECT ... WHERE x = :x", json!({"x": value}))).await?

PRESENCE:
- Peer.peer_key_string → Peer.peer_key: String (unified, Vec<u8> variant removed)
- Peer.is_connected_to_ditto_cloud → Peer.is_connected_to_ditto_server
- Connection.peer_key_string1/2 → Connection.peer1/2
- Connection.approximate_distance_in_meters → removed

TYPES:
- AppId → DatabaseId
- DatabaseId does NOT implement Into<String>. DittoConfig::new takes S: Into<String>,
  so if you have a DatabaseId variable (e.g. parsed from CLI or env), call .to_string() on it:
  let config = DittoConfig::new(app_id.to_string(), connect);
- DiskUsageChild → DiskUsageItem
- Ditto::with_sdk_version(|v| {...}) → Ditto::version() (static, returns String)
- WriteStrategy enum → removed (DQL handles write semantics)
- DittoBuilder → removed (use DittoConfig::new + Ditto::open)

BEFORE (V4):
```rust
let ditto = Ditto::builder()
    .with_root(Arc::new(PersistentRoot::from_current_exe()?))
    .with_identity(|ditto_root| {
        identity::OnlinePlayground::new(
            ditto_root, "your-app-id", "your-token", false,
        )
    })?
    .build()?;

ditto.update_transport_config(|config| {
    config.connect.websocket_urls.insert("wss://...".to_string());
});
ditto.store().execute_v2("ALTER SYSTEM SET DQL_STRICT_MODE = false", None).await?;
ditto.disable_sync_with_v3()?;
ditto.start_sync()?;
```

AFTER (V5):
```rust
struct AuthHandler { token: String }

impl DittoAuthExpirationHandler for AuthHandler {
    async fn on_expiration(&self, ditto: &Ditto, _: Duration) {
        let token = self.token.clone();
        if let Some(auth) = ditto.auth() {
            if let Err(e) = auth.login(&token, &get_development_provider()) {
                println!("Auth failed: {e}");
            }
        }
    }
}

let config = DittoConfig::new(
    "your-database-id",
    DittoConfigConnect::Server {
        url: "REPLACE_ME_WITH_YOUR_URL".parse().unwrap(),
    },
);

let ditto = Ditto::open(config).await?;

let auth = ditto.auth().expect("Auth available in Server mode");
auth.set_expiration_handler(AuthHandler { token: "your-token".to_string() });

ditto.sync().start()?;
```

CHECKLIST:
- Add rust-toolchain.toml with channel = "1.91" (v5 requires rustc 1.91)
- Replace Ditto::builder()...build() with Ditto::open(DittoConfig::new(...))
- Create DittoConfig with database_id and DittoConfigConnect variant
- Use .parse().unwrap() for URL fields (url::Url type)
- Import DittoAuthExpirationHandler, DittoConfig, DittoConfigConnect from crate root (no submodule path)
- Do NOT import std::future::Future — not needed for async fn trait methods
- Implement DittoAuthExpirationHandler on a struct using async fn on_expiration(&self, ...)
- auth.login() is synchronous — handle Result directly
- Use get_development_provider() for dev tokens
- Remove update_transport_config (v5 auto-configures websocket from Server URL)
- Remove disable_sync_with_v3, DQL strict mode workarounds
- Replace _v2 method suffixes
- Replace AppId with DatabaseId
- If app_id is a DatabaseId variable, pass app_id.to_string() to DittoConfig::new — DatabaseId does not impl Into<String> (string literals work directly)
- Replace peer_key_string with peer_key
- Replace is_connected_to_ditto_cloud with is_connected_to_ditto_server
- Update ditto.store to ditto.store() (method, not field)
- Replace start_sync()/stop_sync()/is_sync_active() with sync().start()/sync().stop()/sync().is_active()

Work through the codebase systematically. Show me each file's changes.