feat(chat): fee floor, real delivery status, pay-from-funded, funds pre-check

Chat sends move 0 value, so the network fee is structurally load-bearing (it's
the only thing that forces a real shielded input; 0-value + 0-fee builds a
degenerate, unrelayable tx). Three gaps addressed:

1. Fee floor — broadcastChatMemos now uses max(getDefaultFee(), kChatMinFeeDrgx),
   so a 0 / too-low global default-fee setting can't silently break chat.

2. Real delivery status — the echo was marked Sent on SUBMIT regardless of the
   on-chain outcome (the z_sendmany callback was empty), so failures were
   invisible and the Retry affordance never fired for async failures. Add a third
   ChatDelivery::Sending state (appended so persisted 0=Sent stays valid); record
   the echo in-memory as Sending, and resolve it to Sent/Failed from the
   z_sendmany completion callback — persisting only the final status (so a restart
   never shows a stuck spinner; a stray persisted Sending loads as Sent). A subtle
   "sending…" label shows while in flight.

3. Pay-from-funded + pre-check — z_sendmany spends from one z-address, and the
   identity reply address may be unfunded while funds sit elsewhere. chatPayFromZaddr
   picks a spendable z-address that can cover the fee (preferring the identity
   address); the memo still advertises the identity address as reply-to, so paying
   from a different note is transport-transparent. If nothing can cover the fee, a
   clear "need a small shielded balance" toast replaces the cryptic failure.

Full node only for the callback path; lite resolves optimistically on queue.
8-language strings + CJK subset (+1 glyph 賄).

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

src/chat/chat_service.cpp

@@ -109,4 +109,15 @@ bool ChatService::recordOutgoing(const ChatMessage& message) {
     return false;
 }
 
+bool ChatService::recordOutgoingPending(const ChatMessage& message) {
+    // In-memory only — deliberately NOT persisted yet, so "Sending" never survives to a restart; the
+    // row is written by resolveOutgoing() once the broadcast resolves to Sent/Failed.
+    return store_.append(message);
+}
+
+void ChatService::resolveOutgoing(const std::string& txid, ChatDelivery delivery) {
+    const ChatMessage* updated = store_.updateDelivery(txid, delivery);
+    if (updated && db_) db_->append(*updated);  // first persist, carrying the final status
+}
+
 } // namespace dragonx::chat