fix(CLI-40): scrub the credential from the redacted error's structured reply, route MXACCESS_FAILURE to MxAccess (Rust), fix Go Subscribe terminal-error drop

Code-review follow-up on the CLI-40/41/44 branch.

ISSUE 1 (all five, critical): the message-only scrub still leaked the
server-echoed credential through the redacted error's structured reply accessor
(.NET Reply/Statuses, Java reply()/protocolStatus(), Go MxAccessError.Reply via
errors.As, Rust reply()/into_reply(), Python raw_reply). The redacted error now
carries a scrubbed clone of the reply (protocol_status.message,
diagnostic_message, statuses[].diagnostic_text), with per-language tests asserting
the reply accessor no longer contains the credential.

ISSUE 2 (Rust, critical): ensure_command_success routed MXACCESS_FAILURE to
Error::Command (unlike the other four clients), bypassing attach_secrets and
leaking via derived Debug/Display. MXACCESS_FAILURE now routes to Error::MxAccess,
fixing the cross-client inconsistency.

ISSUE 3 (Go, important): the CLI-44 terminal send was unconditionally
non-blocking, dropping a genuine terminal error under a full buffer on the
never-drop SubscribeEvents path. It is now reserved-slot-non-blocking only for the
cancel-on-overflow path and blocking for the never-drop path.

New shared fixture authenticate-user.echoed-credential-mxaccess-failure.reply.json
wired into all five suites. Minors: whitespace-secret guard on .NET/Java redact
helpers; Java preserves exception subtype on redaction; redaction-helper unit
tests (Go/Java/.NET). Docs (ClientBehaviorFixtures.md, ClientLibrariesDesign.md)
updated to make the structured-field claim true.

clients/rust/src/session.rs

@@ -11,7 +11,7 @@
 use std::sync::atomic::{AtomicU64, Ordering};
 
 use crate::client::{EventStream, GatewayClient};
-use crate::error::{ensure_protocol_success, Error};
+use crate::error::{ensure_protocol_success, Error, MxAccessError};
 use crate::generated::mxaccess_gateway::v1::mx_command::Payload;
 use crate::generated::mxaccess_gateway::v1::mx_command_reply;
 use crate::generated::mxaccess_gateway::v1::{
@@ -1117,16 +1117,46 @@ fn string_secret(value: &MxValue) -> Vec<String> {
 }
 
 /// Attach caller-supplied exact secrets to an [`Error::MxAccess`] before it
-/// propagates, so its `Display` scrubs any occurrence of the credential (e.g. a
-/// password MXAccess echoed back verbatim). Any other error variant is returned
-/// unchanged.
+/// propagates. This both scrubs the stored reply's caller-readable string
+/// fields (so `reply()`/`into_reply()` cannot recover a credential MXAccess
+/// echoed back verbatim) and keeps the secrets on the error as a
+/// belt-and-suspenders for `Display`/`Debug`. Any other error variant is
+/// returned unchanged.
 fn attach_secrets(error: Error, secrets: Vec<String>) -> Error {
     match error {
-        Error::MxAccess(boxed) => Error::MxAccess(Box::new(boxed.with_secrets(secrets))),
+        Error::MxAccess(boxed) => {
+            let mut reply = boxed.into_reply();
+            scrub_reply_strings(&mut reply, &secrets);
+            Error::MxAccess(Box::new(MxAccessError::new(reply).with_secrets(secrets)))
+        }
         other => other,
     }
 }
 
+/// Replace every non-empty secret occurrence with `<redacted>` in the reply's
+/// caller-readable string fields — `protocol_status.message`,
+/// `diagnostic_message`, and each `statuses[i].diagnostic_text`. A caller
+/// reading the structured reply back off an [`Error::MxAccess`] would otherwise
+/// reintroduce the leak that `Display`/`Debug` already close.
+fn scrub_reply_strings(reply: &mut MxCommandReply, secrets: &[String]) {
+    for secret in secrets {
+        if secret.is_empty() {
+            continue;
+        }
+        if let Some(status) = reply.protocol_status.as_mut() {
+            status.message = status.message.replace(secret.as_str(), "<redacted>");
+        }
+        reply.diagnostic_message = reply
+            .diagnostic_message
+            .replace(secret.as_str(), "<redacted>");
+        for status in &mut reply.statuses {
+            status.diagnostic_text = status
+                .diagnostic_text
+                .replace(secret.as_str(), "<redacted>");
+        }
+    }
+}
+
 fn suspend_status(reply: MxCommandReply) -> Result<MxStatus, Error> {
     match reply.payload {
         Some(mx_command_reply::Payload::Suspend(suspend)) => suspend