[MG_Backend, MG_Test] (Disaggregated): P5e ID-117 - the strict knob gains an admitted state

- CountBarrierPull aborted under MOBILEGL_IPC_STRICT_ERRORS on EVERY barrier-pulled read,
  admitted or not. The run's rc is therefore non-zero before CI ever reaches its allowlist
  comparison, so that comparison was unreachable code and "hard green" was impossible with the
  knob as written - the lane could not tell a debt this phase leaves standing from a defect.
- Third state, with the other two untouched: unbarriered stays an unconditional Fatal; barriered
  and NOT admitted stays a Fatal under strict; barriered and admitted logs one MGLOG_W and the
  entry completes. Admission is MGPipeBarrierPullAdmitted, generated from the three tables
  (ID-116), so there is no list here to drift.
- The marker keeps the grammar and changes only the tag: Admitted{UnmigratedPipeInput,
  "<F>@<V>"} [BARRIER-PULLED, ADMITTED, retires in <phase>]. Every filter written since P5c
  matches Fatal{UnmigratedPipeInput and therefore still means exactly "red".
- Deduped per (field, verb) per process. An 852-draw frame reaches an admitted readback row once
  per draw; undeduped, one frame writes 852 identical lines and the marker census is unreadable.
- CHECKED, NOT ASSUMED (the brief's instruction): StrictErrorsTurnsABarrierPulledReadIntoANamedAbort
  and StrictErrorsAlsoPromotesTheStickyForwards both still go red. Both stamp DrawArrays, whose
  op is kWaitNone, so neither pair is admitted.
- ID-119: the old "rsp = 0 on unbarriered records" comment at this function is withdrawn as
  vacuous - the unbarriered arm is [[noreturn]] and runs BEFORE ++g_residualPulls, so the
  sentence was true of every possible implementation.
- Red-once: AnAdmittedBarrierPullIsLoudOnceAndNotFatal is the same sticky forward as the case
  above it under a barriered verb; making the strict arm unconditional again kills it -
  "FieldOwnershipTest.cpp:867: Failure / Actual: false / signal 6".

MobileGL/MG_Test/Pipe/FieldOwnershipTest.cpp

@@ -841,6 +841,53 @@ TEST_F(FieldOwnershipTest, StrictErrorsAlsoPromotesTheStickyForwards) {
         << r.Log;
 }
 
+// P5e (gl) RED-ONCE, ID-117: THE THIRD STATE, AND IT IS THE SAME FIELD AS THE CASE ABOVE.
+//
+// ValidateProgramName@DrawArrays aborts (draw_vbo is kWaitNone: the client will not be parked
+// behind that record and the read is torn by construction). ValidateProgramName@ReadPixels is
+// the same sticky forward under a verb whose op IS statically barriered, so the client is
+// parked, the value is real and ordered, and the debt is P9's rather than this phase's - it
+// says so and the entry COMPLETES. One field, two verbs, opposite verdicts: that is the whole
+// of ID-84 in two cases, and before this change the lane could not tell them apart because
+// strict aborted on both, which made CI's allowlist comparison unreachable code.
+//
+// THE RED: delete the `if (!MGPipeBarrierPullAdmitted(...))` guard in CountBarrierPull so the
+// strict arm is unconditional again, and this case dies of SIGABRT instead of exiting 0.
+TEST_F(FieldOwnershipTest, AnAdmittedBarrierPullIsLoudOnceAndNotFatal) {
+    const ChildResult r = RunInChild([] {
+        MG_Config::Ipc.StrictErrors = true;
+        MGPipeServerStampVerbBoundary(MGPipeVerb::ReadPixels);
+        (void)gPipeInputs.ValidateProgramName(1u);
+        (void)gPipeInputs.ValidateProgramName(1u);
+        (void)gPipeInputs.ValidateProgramName(2u);
+        // rsp counts every barriered pull, and under strict every surviving barriered pull is an
+        // admitted one - ID-119's reworded pin, from the counter's side.
+        if (MGPipeResidualPullCount() != 3) ::_exit(7);
+    });
+    ASSERT_TRUE(ExitedWith(r, 0)) << DescribeStatus(r) << "\n" << r.Log;
+    EXPECT_EQ(r.Log.find("Fatal{UnmigratedPipeInput"), std::string::npos)
+        << "an admitted pull aborted: the lane can never be green while a debt this phase "
+           "deliberately leaves standing is fatal\n"
+        << r.Log;
+    // THE GRAMMAR, VERBATIM. `<field>@<verb>` and the bracketed tail are the Fatal's, character
+    // for character; only the leading tag differs, so every filter written since P5c that
+    // matches `Fatal{UnmigratedPipeInput` still means exactly "red".
+    EXPECT_NE(r.Log.find("MGPipe: Admitted{UnmigratedPipeInput, \"ValidateProgramName@ReadPixels\"}"
+                         " [BARRIER-PULLED, ADMITTED, retires in P9]"),
+              std::string::npos)
+        << r.Log;
+    // DEDUPED PER (field, verb): three pulls, one line. An 852-draw frame must not write 852.
+    SizeT lines = 0;
+    for (std::size_t at = r.Log.find("Admitted{UnmigratedPipeInput"); at != std::string::npos;
+         at = r.Log.find("Admitted{UnmigratedPipeInput", at + 1)) {
+        ++lines;
+    }
+    EXPECT_EQ(lines, SizeT{1})
+        << "the admitted marker is not deduped per (field, verb); a frame of draws would write "
+           "one line per pull and the marker census could not be read\n"
+        << r.Log;
+}
+
 // A FATAL-class read aborts whatever the knob says: no carrier, and the reduced path never
 // reads it, so it is a real defect rather than a debt.
 // P5b i1: the exemplar MOVED. This case used GetProgramForDispatch, which is BARRIER-PULLED