[MG_Remote] (P6/dl): every session death goes through one funnel

Step two of CONTRACT-P6 5.2. The ~90 scattered `MGLOG_F("...Fatal{...}"); std::abort();`
pairs under MG_Remote/ become one call each to SessionFail(MGFatalFamily, fmt, ...),
which logs, echoes to stderr, counts, and aborts in one place. a6's census
found no single chokepoint existed; now there is one, and step three hangs the
SessionFault-to-peer publish off it.

THE MESSAGE STRING IS PASSED VERBATIM. The contract requires the log lines, the
CI greps and every red-once byte-identical, so SessionFail does not compose the
line from the family - it takes the SAME string the site handed MGLOG_F and
forwards it unchanged. The family enum rides alongside, redundantly, so the
funnel has the coarse wire FatalCode without parsing the string. The census now
checks that redundancy the way it checks WireLogFatal: every SessionFail call's
string must carry a Fatal{ word, so the enum and the string cannot silently
disagree.

The conversion was mechanical - 89 sites by a transform that injects the family
as MGLOG_F's new first argument and drops the trailing abort - with three sites
fixed by hand that the transform would have broken: a stub macro, and two
if/else-then-shared-abort blocks (PersistentMapTracker's adopt-tier and
SurfaceOpCodec's three surface-error branches) where a naive rewrite stole the
abort from the earlier branches and would have let them fall through. The
death tests are the safety net for byte-identity, and every one stayed green.

Four std::abort() remain under MG_Remote/, all inside the two funnels
(WireLog.cpp, FatalFunnel.cpp); the census exempts both files because their
callers carry the family word, and its baseline drops from 93 aborts to 4.
SessionFaultCount() is the one telemetry point S8 will assert zero over a good
run.

G1 re-measured: 0 symbol diff, .text unchanged at 0xa52203 (FatalFunnel and
FatalFamily live under MG_Remote/, compiled only in the disaggregated build).
Unit 2358 (one pre-existing environmental failure), integration-split 186/186,
integration-spawn 102/102, retrace 6/6, census 0 unmarked.

MobileGL/MG_Remote/Protocol/SurfaceOpCodec.cpp

@@ -7,6 +7,7 @@
 // End of Source File Header
 
 #include "SurfaceOpCodec.h"
+#include <MG_Remote/FatalFunnel.h>
 
 #include <MG_Backend/BackendObject.h>
 #include <MG_Remote/Protocol/generated/protocol_generated.h>
@@ -207,22 +208,24 @@ namespace MobileGL::MG_Remote {
         const SurfaceWireError error = DecodeWireSurfaceOp(op, &frame);
         if (error != SurfaceWireError::None) {
             if (error == SurfaceWireError::AndroidNativeWindowArrived) {
-                MGLOG_F("MGPipe: Fatal{UnmigratedSurface, \"AndroidNativeWindow@P12\"} - a wire "
+                SessionFail(MGFatalFamily::UnmigratedSurface,
+                        "MGPipe: Fatal{UnmigratedSurface, \"AndroidNativeWindow@P12\"} - a wire "
                         "SurfaceOp (%s) named an ANativeWindow*, which is a pointer into the "
                         "CLIENT's process and means nothing here. Real window arrival is P12; "
                         "until then the spawn surface path is pbuffer/surfaceless only",
                         ::MobileGL::Wire::EnumNameSurfaceOpKind(op.kind()));
             } else if (error == SurfaceWireError::MetalLayerArrived) {
-                MGLOG_F("MGPipe: Fatal{UnmigratedSurface, \"MetalLayer@P12\"} - a wire "
+                SessionFail(MGFatalFamily::UnmigratedSurface,
+                        "MGPipe: Fatal{UnmigratedSurface, \"MetalLayer@P12\"} - a wire "
                         "SurfaceOp named a CAMetalLayer* in the CLIENT's process. "
                         "Real window arrival is P12");
             } else {
-                MGLOG_F("MGPipe: Fatal{ProtocolCorruption, \"SurfaceOp\"} - a wire surface op "
+                SessionFail(MGFatalFamily::ProtocolCorruption,
+                        "MGPipe: Fatal{ProtocolCorruption, \"SurfaceOp\"} - a wire surface op "
                         "failed validation: %s (wire kind %u, window kind %u)",
                         SurfaceWireErrorName(error), static_cast<unsigned>(op.kind()),
                         static_cast<unsigned>(op.windowKind()));
             }
-            std::abort();
         }
         const MobileGLResult rc = Server::ServerLoopInstance().RunSurfaceControlFrame(frame);
         if (replyOut != nullptr) *replyOut = frame;