feat(chat): persistent, seed-encrypted message store (Phase 2)

Swap the in-memory-only chat store for durable sqlite persistence with real
per-transaction timestamps, encrypted at rest under a key derived from the
wallet's own seed (no passphrase, works on encrypted and unencrypted wallets).

- ChatDatabase (src/chat/chat_database.{h,cpp}): sqlite store mirroring
  data::TransactionHistoryCache. unlockWithSecret(seed) derives a 32-byte AEAD
  storage key and a wallet-partition tag via domain-separated keyed BLAKE2b
  (generichash) contexts. Every record — bodies, peer z-addrs, threading,
  timestamps — is crypto_aead_xchacha20poly1305_ietf-encrypted with a random
  nonce and the wallet tag as associated data; even the dedup key is a keyed
  hash of txid+position, so nothing about your conversations is in cleartext on
  disk. Rows are partitioned per-wallet; a different seed sees nothing. Messages
  are decrypted once at ingest then re-encrypted under the storage key, so
  load() needs only the storage key, not the chat identity.
- ChatService: ingest() now stamps each message with its own transaction time
  (txid->time map + fallback) and writes new (store-deduped) messages through to
  the database; loadFromDatabase() rehydrates the in-memory read model on unlock.
- App: unlock the chat DB with the same seed in provisionChatIdentityFromSecret
  and load prior history; lock the DB + clear the decrypted in-memory store on
  relock and on lite-controller rebuild.

Adversarial review (4 confirmed findings, all fixed): don't provision if the
wallet locks mid-fetch (re-check isLocked at completion); wipe the serialized
plaintext temporary in append(); trim the seed into a separate fully-wiped
buffer (no residue past a shrunk size()); scrub the mnemonic copy in the RPC
json result.

Tests: ChatDatabase round-trip (persist/reload, field + order fidelity), dedup,
per-wallet isolation, lock inertness, and ChatService write-through + reload
without an identity. Gated by DRAGONX_ENABLE_CHAT (default OFF). Verified:
Linux + Windows(mingw) build with chat ON, ctest 100%, hygiene clean; caches
restored to the OFF default.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/chat/chat_service.cpp

@@ -2,6 +2,8 @@
 
 #include "chat_service.h"
 
+#include "chat_database.h"
+
 #include <utility>
 
 namespace dragonx::chat {
@@ -21,7 +23,8 @@ void ChatService::clearIdentity() {
 }
 
 int ChatService::ingest(const std::vector<HushChatTransactionMetadata>& metadata,
-                        std::int64_t txTimestamp) {
+                        const std::unordered_map<std::string, std::int64_t>& txTimestamps,
+                        std::int64_t fallbackTimestamp) {
     if (!has_identity_) return 0;
 
     int added = 0;
@@ -32,7 +35,8 @@ int ChatService::ingest(const std::vector<HushChatTransactionMetadata>& metadata
         message.conversation_id = meta.conversation_id;
         message.peer_zaddr = meta.reply_zaddr;
         message.peer_public_key_hex = meta.sender_public_key_hex;
-        message.timestamp = txTimestamp;
+        const auto timeIt = txTimestamps.find(meta.txid);
+        message.timestamp = timeIt != txTimestamps.end() ? timeIt->second : fallbackTimestamp;
         message.payload_position = meta.payload_position;
 
         if (meta.type == HushChatHeaderType::ContactRequest) {
@@ -48,9 +52,22 @@ int ChatService::ingest(const std::vector<HushChatTransactionMetadata>& metadata
             message.body = std::move(plaintext);
         }
 
-        if (store_.append(message)) ++added;
+        // In-memory store dedups (txid+position); only persist the genuinely new ones. On the next
+        // session loadFromDatabase() repopulates the store, so re-scanning the chain re-ingests but
+        // the store dedup prevents a duplicate write.
+        if (store_.append(message)) {
+            if (db_) db_->append(message);
+            ++added;
+        }
     }
     return added;
 }
 
+void ChatService::loadFromDatabase() {
+    if (!db_) return;
+    for (const auto& message : db_->load()) {
+        store_.append(message);
+    }
+}
+
 } // namespace dragonx::chat