feat(daemon): deliver stop reliably and never kill the node unasked

Closing the wallet sent "stop" at most twice, gated on a getinfo probe
that needs the daemon's cs_main, then killed the node after 20 s (Windows)
or 30 s (POSIX) whether or not stop had arrived. A node busy with an
hour-long witness rebuild therefore never got stop, was killed mid-
rebuild, and replayed everything since its last flush on every start.

Delivery (src/daemon/stop_delivery.h, RPCClient::open/trySendStop):
- stop goes over a dedicated client with no probe, so it never waits on
  rpc_'s lock or a cs_main-bound getinfo
- every attempt is classified, and StopDeliveryPolicy decides the next:
  Accepted / 503 = delivered; Queued (reply timeout) is resent at most
  every 30 s; QueueFull / not listening are retried every 1.5 s; a
  refusal after we were heard means the node is shutting down; a 401 on
  our own node tries the next credential source
- POSIX: a group SIGTERM goes out as soon as an attempt fails, which
  bypasses the HTTP queue entirely

Waiting (DaemonController::executeDaemonStop, pure, virtual-clock
tested):
- never kills on its own. Quitting waits as long as the node needs; the
  shutdown screen offers "Close wallet — leave node running" after 3 s,
  and "Kill node (unsafe)" (confirmed) only once stop was delivered and
  the node showed no CPU/I-O progress for ~10 min outside a rebuild
- other callers (restart, rescan, reinstall, switch, ...) wait up to
  120 s, let go once the app starts quitting, and keep watching a node
  that is still running; wallet switch refuses to go ahead then
- EmbeddedDaemon gains stop-session primitives (beginStop,
  pollOwnedProcess, signalGracefulStop, forceKillOwnedProcess,
  ownedResourceUsage over the Linux process group / Windows handle,
  endStop) and only one stop session runs at a time
- the Force Quit button and its stall heuristic are gone; "Leave
  running" aborts a pending stop attempt and closes at once

Verified against the fake daemon with the real GUI: closing mid-rebuild
now delivers stop (or SIGTERM 2 ms after a queue-full refusal) and the
node exits cleanly after its rebuild, where it was SIGKILLed before. The
shutdown screen, its "Leave running" button and the idle Kill offer
(after ~11 min) were checked by screenshot. New strings are English-
only for now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/rpc/rpc_client.h

@@ -64,6 +64,23 @@ public:
                  const std::string& user, const std::string& password,
                  bool useTls);
 
+    /**
+     * @brief Set up the connection without probing it (connect() = open() + a getinfo probe)
+     *
+     * For sending "stop": the getinfo probe needs the daemon's cs_main, so against a busy node it
+     * times out (holding one of the daemon's few RPC slots) or is refused, and stop never went out.
+     * isConnected() stays false; call() works once this returns true.
+     */
+    bool open(const std::string& host, const std::string& port,
+              const std::string& user, const std::string& password, bool useTls);
+
+    /**
+     * @brief Send "stop" once, with its own timeout; returns how it went (None = the daemon ran it)
+     *
+     * A ReplyTimeout here is NOT a failure: the request reached the daemon and waits for a worker.
+     */
+    RpcFailureKind trySendStop(long timeoutSec = 2);
+
     /**
      * @brief Disconnect from dragonxd
      */
@@ -265,6 +282,7 @@ private:
     // A non-200 reply: RpcError when the body carries a JSON-RPC error, else RpcTransportError classified
     // from the status and plain-text body. hideBody keeps the body out of the message (secret calls).
     [[noreturn]] static void throwHttpFailure(long httpCode, const std::string& body, bool hideBody);
+    bool probeConnection(const std::string& host);   // connect()'s getinfo probe, after open()
     void logConnectFailure(const std::string& msg);
 
     // Splits a UnifiedCallback into the (Callback, ErrorCallback) pair used by doRPC.