[MG_Backend, MG_Impl, MG_Util, MG_Test, MG_IntegrationTest, docs] (P7): the server publishes kCapResidentSubData off its own wire resource table

CONTRACT-P7 §5.4, OQ-10. InitServerRoleCommon computes the whole capability mask and
never ORed this bit, so MGPipeResourceOpsHaveSubDataResident answered false under every
transport and BOTH backends were pinned to the ordered in-place host memcpy - which made
Magma's SubDataResident arm (VkBufferManager.cpp's g_vulkanWireResourceOps) dead code on
the wire even though the arm has been there since P5f.

The bit is derived from g_resourceOpsAtStep2->SubDataResident, i.e. from the pointer this
function already pinned at step 2 and that step 5 already refuses to see swapped - never
from ActiveBackendType. That is ID-39's lesson and not a style preference: a mask is a
statement about THIS backend's registered table, and a bit derived from the enum would
keep claiming the capability for a build, a flavour or a future backend whose table does
not carry the arm.

`rsd=` joins the emit[] bracket on the PipeStats summary line, counted at the emitter once
per buffer_subdata_resident record rather than once per call, because a write past the
content chunk cap is cut into several records. It is the only observable that separates
the resident arm from the memcpy beside it: the bytes in the buffer are identical either
way, which is exactly how the capability stayed unpublished for a phase with every lane
green.

WHAT THIS DOES NOT YET PROVE, and R-6 is the reason rather than an omission. §5.4 asks for
a white-box case showing opcode 49 on the wire. None can exist at this tree: the resident
arm is reached only from a GPU-RESIDENT store, residency comes only from
AdoptPersistentMap, and every persistent-map acquisition declines under split by R-6
(PipeApply.cpp:2331 "A SPLIT BUILD RUNS AT TIER T2 AND DECLINES EVERY ACQUISITION,
ALWAYS"; T0/T1 are P11's and AdoptTierIsEmulate is a named Fatal for them). So the
capability is wired AHEAD of its consumer, deliberately, and `rsd=` is what will show the
records the day P11 lands a tier that adopts. Filed for the integrator in
notes/p7/magma-c.md.

What IS proved is both halves of the bit itself. RemoteClientTest's Magma bootstrap case
now asserts the published bit EQUALS `ops->SubDataResident != nullptr` - the two compared
to each other rather than both to true, so the case also covers a backend without the arm
on the day one exists - and a new CtWireScenario case reads the bit out of the client's
own caps mirror, through the same accessor the frontend reads, on both backends and all
three transports.

RED-ONCE, both levels. Deleting the OR reds
CapsMirrorTest.MagmaTransportPublishesRealBufferConsumersWithoutRunAhead
(RemoteClientTest.cpp:692, "Which is: false / Which is: true") and all SIX arms of
DirectGLES/DirectVulkan x {Split,Spawn,Tcp} Ct.TheServerPublishesTheResidentSubData
CapabilityFromItsOwnTable ("the client's caps mirror did not receive
kCapResidentSubData"). Restored: green.

Also carries the P4a death-helper comment from the previous commit's sweep: it no longer
says Magma installs no death table, because it now does and still frees no slot.

MobileGL/MG_Backend/Init.cpp

@@ -220,6 +220,32 @@ namespace MobileGL::MG_Backend {
                         capBits |= MG_Pipe::kCapTimerQuery;
                 }
             }
+            // P7 wave 2 package C, OQ-10 (CONTRACT-P7 §5.4): kCapResidentSubData, PUBLISHED
+            // OFF THE SERVER'S OWN WIRE RESOURCE TABLE AND NOTHING ELSE.
+            //
+            // The question the bit answers is the one BufferObject::LandBytesIntoResidentStore
+            // asks before it chooses between emitting `buffer_subdata_resident` (opcode 49) and
+            // falling back to the ordered in-place host memcpy: "does the side that will APPLY
+            // this record implement the resident arm at all?" Under a transport the client has
+            // no op table to probe - MGPipeResourceOpsHaveSubDataResident says so in as many
+            // words (MG_Impl/Pipe/PipeFill.cpp) and reads this bit instead - and until now
+            // nothing ever set it, so the answer was permanently "no" and BOTH backends fell
+            // back to the memcpy while both of them in fact register a SubDataResident arm
+            // (DirectGLES Managers.cpp's g_glesResourceOps, Magma VkBufferManager.cpp's
+            // g_vulkanWireResourceOps). Magma's implementation was dead code on the wire.
+            //
+            // BY THE TABLE, NEVER BY THE BACKEND ENUM, and that is ID-39's lesson rather than a
+            // style preference: a mask is a statement about THIS backend's registered table, so
+            // a bit derived from `ActiveBackendType == ...` would keep claiming the capability
+            // for a build, a flavour or a future backend whose table does not carry the arm -
+            // which is exactly how 66 uploads were lost to a consumer bit that nobody could
+            // have honoured. `g_resourceOpsAtStep2` is the pointer this function just pinned,
+            // and step 5 already refuses a run where that pointer was swapped underneath us, so
+            // reading the arm off it means the published bit and the table that has to answer
+            // for it cannot come apart.
+            if (g_resourceOpsAtStep2 != nullptr && g_resourceOpsAtStep2->SubDataResident != nullptr) {
+                capBits |= MG_Pipe::kCapResidentSubData;
+            }
             // Each backend has an independent implementation-readiness gate.
             // The runtime RunAhead knob can decline the feature, never create it.
             const Bool runAheadReady = MG_Config::ActiveBackendType == BackendType::DirectVulkan