Rust V4→V5 API Migration Guide

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

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() }
- 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 handler callable multiple times (AsyncFn, NOT AsyncFnOnce)
- IMPORTANT: async move closures that capture variables will NOT compile — they implement AsyncFnOnce only
- IMPORTANT: async closures without move capture by reference and won't satisfy the 'static bound
- RECOMMENDED: Implement DittoAuthExpirationHandler on a struct that holds captured state (token, config)
  - on_expiration takes &self, so the struct persists; .clone() state into each async block
  - Call ditto.auth() synchronously before the async move block to avoid lifetime issues
- 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)

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
- 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
use std::future::Future;

// Struct-based handler — async move closures with captured state won't compile
struct AuthHandler { token: String }
impl DittoAuthExpirationHandler for AuthHandler {
    fn on_expiration(&self, ditto: &Ditto, _: Duration) -> impl Send + Future<Output = ()> {
        let token = self.token.clone();
        let auth = ditto.auth();
        async move {
            if let Some(auth) = 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: "https://your-server.ditto.live".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:
- 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)
- Implement DittoAuthExpirationHandler on a struct (NOT async move closures with captured state)
- 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
- 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() with sync().start()/sync().stop()

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