[Feat] (State): give the frontend six aggregate generations so a tracker can answer "did any bound texture, buffer, attachment or attribute move" with one Uint64 compare

- MGP_NOTE_AGGREGATE(Aggregate) next to MGP_NOTE_MUTATION in MG_Pipe/PipeMutation.h, ((void)0)
  in the pull build for the same reason and with the same shape. It answers a DIFFERENT
  question from MGP_NOTE_MUTATION - "did any object of this class move since the tracker last
  looked", not "did a backend move a frontend value inside its own verb" - which is why it is a
  second macro rather than an overload.
- The counters are members of the owning MG_State container (VertexArrayState,
  FramebufferState, TextureState x2, BufferState) and are reached through a push-only GLContext
  facade, because the bump points sit on OBJECTS and an object has no back-pointer to the state
  that owns it. That is the free-function form P2 brief D4 allows, and it costs a global load on
  a path that has just written object state.
- A SIXTH aggregate, VertexAttribDefault on GLContext, which D4 does not list. Its bit
  (NEW_VERTEX_ATTRIB_DEFAULTS) is specified there with a ContentHash over all 32
  CurrentVertexAttributeValues, and hashing 768 bytes on every draw does not fit inside the T1
  ceiling the same brief pins. The hash still decides whether to EMIT (D11's set-hash
  suppressor); the generation decides whether to hash at all.
- 30 bump points: 3 VertexArrayObject config-version sites, 3 FramebufferObject object-version
  sites (one of them inside MOBILEGL_DEFINE_FRAMEBUFFER_DEFAULT_SETTER, so the statement
  carries its own line continuation), 5 texture content-version sites, 12 texture
  params-version sites, SamplerObject::BumpVersion as the sampler choke point, 7 BufferObject
  change-serial sites and the 3 glVertexAttrib* defaults.
- Every counter is deliberately COARSER than the state it guards: over-firing costs one extra
  push, under-firing renders stale, and under-firing is the direction ARCHITECTURE.md 13.2
  names as the dangerous one and the P1 verify comparator cannot see for object-class state.
- TrackerTest: each bump point moves ITS aggregate and no other, plus a null-context note.
- G1: the pull build is 0 added / 0 removed / 0 renamed and the four resized symbols are the
  contract commit's own, unchanged by this commit.

MobileGL/MG_Impl/Pipe/PipeFill.cpp

@@ -490,6 +490,39 @@ namespace MobileGL::MG_Pipe {
         MGPipeFillAccess::CopyField(inputs, *ctx, field);
     }
 
+    // ---- the aggregate generations (P2 brief D4) ----
+    // MGP_NOTE_AGGREGATE lands here. The bump points are on OBJECTS, which have no
+    // back-pointer to the state container that owns them, so the note finds the live
+    // context - the same shape, and for the same reason, as MGPipeNoteFrontendMutation
+    // above. No verb has to be in flight and no field is stamped: an aggregate generation
+    // is not a PipeInputs field, it is what the tracker's shutter compares against.
+    void MGPipeNoteAggregate(MGPipeAggregate aggregate) {
+        auto* ctx = LiveContext();
+        if (ctx == nullptr) return;
+        switch (aggregate) {
+        case MGPipeAggregate::VaoAttribute:
+            ctx->NoteVaoAttributeChanged();
+            break;
+        case MGPipeAggregate::FramebufferAttachment:
+            ctx->NoteFramebufferAttachmentChanged();
+            break;
+        case MGPipeAggregate::TextureContent:
+            ctx->NoteTextureContentChanged();
+            break;
+        case MGPipeAggregate::TextureParams:
+            ctx->NoteTextureParamsChanged();
+            break;
+        case MGPipeAggregate::BufferChange:
+            ctx->NoteBufferChanged();
+            break;
+        case MGPipeAggregate::VertexAttribDefault:
+            ctx->NoteVertexAttribDefaultChanged();
+            break;
+        case MGPipeAggregate::Count:
+            break;
+        }
+    }
+
     void MGPipeSetPoisonOmission(const char* verb, const char* field) {
         if (verb == nullptr || field == nullptr) {
             g_omission = PoisonOmission{};