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_message.h

@@ -10,9 +10,11 @@ namespace dragonx::chat {
 
 enum class ChatDirection { Incoming, Outgoing };
 enum class ChatMessageKind { Message, ContactRequest };
-// Outgoing delivery: Sent = the broadcast was submitted; Failed = it wasn't (not connected, no
-// spendable address, a send already in progress). Always Sent for incoming.
-enum class ChatDelivery { Sent, Failed };
+// Outgoing delivery status. Sending = broadcast in flight (async op not yet resolved); Sent = the
+// daemon accepted + broadcast the tx; Failed = it didn't (not connected, no funded address, rejected).
+// Always Sent for incoming. NB: the values are persisted (chat DB serializes the int), so Sent MUST
+// stay 0 and new states are APPENDED — never reordered.
+enum class ChatDelivery { Sent, Failed, Sending };
 
 struct ChatMessage {
     ChatDirection direction = ChatDirection::Incoming;