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

@@ -0,0 +1,53 @@
+#pragma once
+
+// DragonX Wallet - HushChat outgoing memo construction (the inverse of the receive parser).
+//
+// Given the sender's identity and the peer, produce the header memo JSON + payload memo that,
+// sent as two 0-value memo outputs to the peer's z-address (header at the LOWER memo position),
+// another HushChat client parses and decrypts. The byte format matches SilentDragonXLite: the
+// header keys serialize alphabetically (nlohmann default) to cid,e,h,p,t,v,z. Pure — no I/O, no
+// network; broadcasting the memos is the caller's job (the transport lands in a later phase).
+
+#include "chat_crypto.h"  // ChatKeyPair
+
+#include <string>
+
+namespace dragonx::chat {
+
+struct OutgoingChatMemos {
+    std::string recipientZaddr;  // the peer's z-address (recipient of both memo outputs)
+    std::string headerMemo;      // JSON header — MUST occupy the lower memo position on the wire
+    std::string payloadMemo;     // ciphertext hex (Message) or plaintext (ContactRequest)
+};
+
+enum class ChatComposeStatus {
+    Ok,
+    EmptyBody,
+    MissingField,
+    BadPeerKey,
+    BadRequestText,  // a contact request text must not start with '{' (parser would read it as a header)
+    EncryptFailed,
+    TooLong          // a resulting memo exceeds the HushChat 512-byte memo limit
+};
+
+// Build an ENCRYPTED message to a peer whose public key you already learned from a memo they sent
+// you. `mine` is the sender's identity keypair; `myPublicKeyHex` its public half (goes in header p).
+ChatComposeStatus buildOutgoingMessage(const ChatKeyPair& mine,
+                                       const std::string& myPublicKeyHex,
+                                       const std::string& myReplyZaddr,
+                                       const std::string& peerPublicKeyHex,
+                                       const std::string& peerZaddr,
+                                       const std::string& conversationId,
+                                       const std::string& plaintext,
+                                       OutgoingChatMemos& out);
+
+// Build a plaintext contact request — no peer public key needed yet; this is how the peer first
+// learns your public key + reply address. The payload is the (plaintext) request text.
+ChatComposeStatus buildOutgoingContactRequest(const std::string& myPublicKeyHex,
+                                              const std::string& myReplyZaddr,
+                                              const std::string& peerZaddr,
+                                              const std::string& conversationId,
+                                              const std::string& requestText,
+                                              OutgoingChatMemos& out);
+
+} // namespace dragonx::chat