chore: rename project quicnprotochat -> quicproquo (binaries: qpq)

Rename the entire workspace:
- Crate packages: quicnprotochat-{core,proto,server,client,gui,p2p,mobile} -> quicproquo-*
- Binary names: quicnprotochat -> qpq, quicnprotochat-server -> qpq-server,
  quicnprotochat-gui -> qpq-gui
- Default files: *-state.bin -> qpq-state.bin, *-server.toml -> qpq-server.toml,
  *.db -> qpq.db
- Environment variable prefix: QUICNPROTOCHAT_* -> QPQ_*
- App identifier: chat.quicnproto.gui -> chat.quicproquo.gui
- Proto package: quicnprotochat.bench -> quicproquo.bench
- All documentation, Docker, CI, and script references updated

HKDF domain-separation strings and P2P ALPN remain unchanged for
backward compatibility with existing encrypted state and wire protocol.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

crates/quicproquo-core/src/keystore.rs

@@ -0,0 +1,147 @@
+use std::{
+    collections::HashMap,
+    fs,
+    path::{Path, PathBuf},
+    sync::RwLock,
+};
+
+use openmls_rust_crypto::RustCrypto;
+use openmls_traits::{
+    key_store::{MlsEntity, OpenMlsKeyStore},
+    OpenMlsCryptoProvider,
+};
+
+/// A disk-backed key store implementing `OpenMlsKeyStore`.
+///
+/// In-memory when `path` is `None`; otherwise flushes the entire map to disk on
+/// every store/delete so HPKE init keys survive process restarts.
+#[derive(Debug)]
+pub struct DiskKeyStore {
+    path: Option<PathBuf>,
+    values: RwLock<HashMap<Vec<u8>, Vec<u8>>>,
+}
+
+#[derive(thiserror::Error, Debug, PartialEq, Eq)]
+pub enum DiskKeyStoreError {
+    #[error("serialization error")]
+    Serialization,
+    #[error("io error: {0}")]
+    Io(String),
+}
+
+impl DiskKeyStore {
+    /// In-memory keystore (no persistence).
+    pub fn ephemeral() -> Self {
+        Self {
+            path: None,
+            values: RwLock::new(HashMap::new()),
+        }
+    }
+
+    /// Persistent keystore backed by `path`. Creates an empty store if missing.
+    pub fn persistent(path: impl AsRef<Path>) -> Result<Self, DiskKeyStoreError> {
+        let path = path.as_ref().to_path_buf();
+        let values = if path.exists() {
+            let bytes = fs::read(&path).map_err(|e| DiskKeyStoreError::Io(e.to_string()))?;
+            if bytes.is_empty() {
+                HashMap::new()
+            } else {
+                bincode::deserialize(&bytes).map_err(|_| DiskKeyStoreError::Serialization)?
+            }
+        } else {
+            HashMap::new()
+        };
+
+        Ok(Self {
+            path: Some(path),
+            values: RwLock::new(values),
+        })
+    }
+
+    fn flush(&self) -> Result<(), DiskKeyStoreError> {
+        let Some(path) = &self.path else {
+            return Ok(());
+        };
+        let values = self.values.read().map_err(|_| DiskKeyStoreError::Io("lock poisoned".into()))?;
+        let bytes = bincode::serialize(&*values).map_err(|_| DiskKeyStoreError::Serialization)?;
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).map_err(|e| DiskKeyStoreError::Io(e.to_string()))?;
+        }
+        fs::write(path, bytes).map_err(|e| DiskKeyStoreError::Io(e.to_string()))
+    }
+}
+
+impl Default for DiskKeyStore {
+    fn default() -> Self {
+        Self::ephemeral()
+    }
+}
+
+impl OpenMlsKeyStore for DiskKeyStore {
+    type Error = DiskKeyStoreError;
+
+    fn store<V: MlsEntity>(&self, k: &[u8], v: &V) -> Result<(), Self::Error> {
+        let value = serde_json::to_vec(v).map_err(|_| DiskKeyStoreError::Serialization)?;
+        let mut values = self.values.write().map_err(|_| DiskKeyStoreError::Io("lock poisoned".into()))?;
+        values.insert(k.to_vec(), value);
+        drop(values);
+        self.flush()
+    }
+
+    fn read<V: MlsEntity>(&self, k: &[u8]) -> Option<V> {
+        let values = match self.values.read() {
+            Ok(v) => v,
+            Err(_) => return None,
+        };
+        values
+            .get(k)
+            .and_then(|bytes| serde_json::from_slice(bytes).ok())
+    }
+
+    fn delete<V: MlsEntity>(&self, k: &[u8]) -> Result<(), Self::Error> {
+        let mut values = self.values.write().map_err(|_| DiskKeyStoreError::Io("lock poisoned".into()))?;
+        values.remove(k);
+        drop(values);
+        self.flush()
+    }
+}
+
+/// Crypto provider that couples RustCrypto with a disk-backed key store.
+#[derive(Debug)]
+pub struct StoreCrypto {
+    crypto: RustCrypto,
+    key_store: DiskKeyStore,
+}
+
+impl StoreCrypto {
+    pub fn new(key_store: DiskKeyStore) -> Self {
+        Self {
+            crypto: RustCrypto::default(),
+            key_store,
+        }
+    }
+}
+
+impl Default for StoreCrypto {
+    fn default() -> Self {
+        Self::new(DiskKeyStore::ephemeral())
+    }
+}
+
+impl OpenMlsCryptoProvider for StoreCrypto {
+    type CryptoProvider = RustCrypto;
+    type RandProvider = RustCrypto;
+    type KeyStoreProvider = DiskKeyStore;
+
+    fn crypto(&self) -> &Self::CryptoProvider {
+        &self.crypto
+    }
+
+    fn rand(&self) -> &Self::RandProvider {
+        &self.crypto
+    }
+
+    fn key_store(&self) -> &Self::KeyStoreProvider {
+        &self.key_store
+    }
+}