feat(chat): composer + contact requests — outgoing construction (Phase 4)

Add the outgoing side of HushChat: compose messages and start conversations.
The wire construction is the byte-exact inverse of the receive parser and is
proven by a self-consistent round-trip (build → parse → decrypt).

- src/chat/chat_outgoing.{h,cpp} (pure): buildOutgoingMessage encrypts via
  encryptOutgoing and buildOutgoingContactRequest carries plaintext; both emit
  the header memo JSON ({h,v,z,cid,t,e,p}, which nlohmann serializes
  alphabetically to match SilentDragonXLite) + the payload memo, validating the
  512-byte memo limit, the 64-hex peer key, and the "no leading '{'" rule for
  request text. My public key goes in header "p"; the peer's key is the
  encryption recipient.
- ChatService: composeMessage/composeContactRequest (encrypt with the held
  identity) + recordOutgoing (echo an Outgoing ChatMessage into the store + DB —
  we never harvest our own sends, so this is the only local record).
- App: sendChatMessage(cid,text) sources the peer z-addr + public key from the
  conversation, composes, and records a random-id echo; startChatConversation
  (zaddr,text) mints a random cid + composes a plaintext contact request;
  chatReplyZaddr() picks a spendable z-addr. broadcastChatMemos() is the Phase-5
  transport seam (network delivery + real-SDXL interop verification land there).
- Chat tab: a message composer (shown once the peer's key is known, else a
  "waiting for reply" hint) + a "New conversation" modal that sends a contact
  request to a z-address.
- Tests: outgoing round-trip through the receive parser + decrypt, contact-request
  passthrough, validation guards, and ChatService compose + recordOutgoing echo.

Adversarially reviewed (crypto/interop, secret hygiene, logic, UI) — 0 findings.
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.h

@@ -7,6 +7,7 @@
 
 #include "chat_crypto.h"     // ChatKeyPair
 #include "chat_protocol.h"   // HushChatTransactionMetadata
+#include "chat_outgoing.h"   // OutgoingChatMemos, ChatComposeStatus
 #include "chat_store.h"
 
 #include <cstdint>
@@ -50,6 +51,27 @@ public:
     // the seed-derived key) into the in-memory store. No-op without an unlocked database.
     void loadFromDatabase();
 
+    // --- Outgoing (compose) ---
+    // My chat public key (hex), or "" without an identity — goes in an outgoing header's "p".
+    std::string identityPublicKeyHex() const;
+    // Construct the outgoing memos for an ENCRYPTED message, using the held identity to encrypt.
+    ChatComposeStatus composeMessage(const std::string& myReplyZaddr,
+                                     const std::string& peerPublicKeyHex,
+                                     const std::string& peerZaddr,
+                                     const std::string& conversationId,
+                                     const std::string& plaintext,
+                                     OutgoingChatMemos& out) const;
+    // Construct the outgoing memos for a plaintext contact request (no peer key needed yet).
+    ChatComposeStatus composeContactRequest(const std::string& myReplyZaddr,
+                                            const std::string& peerZaddr,
+                                            const std::string& conversationId,
+                                            const std::string& requestText,
+                                            OutgoingChatMemos& out) const;
+    // Echo a locally-composed outgoing message into the store (and DB). Returns true if new. (We
+    // never harvest our own sent memos — they land on the peer's address — so this echo is the
+    // only local record of what we sent.)
+    bool recordOutgoing(const ChatMessage& message);
+
     const ChatStore& store() const { return store_; }
     ChatStore& store() { return store_; }