refactor(disaggregation): gating skip on ANY strict header, not just [0]

Reviewer flagged the [0] shortcut on filter.go's header-pin check:
Selectors[0] being "the revision axis" is an implicit derivation
(revisionLabelKey = Selectors[0].LabelKey inside newController), not
anything the config surface names. Leaking that convention into the
gating fast path made the code fragile — a config that puts a non-
revision selector first would silently break the check.

Simpler and safer rule: any strict pin from the client means "I've
expressed a constraint, respect it." Skip gating and let the strict
filter do the narrowing. The picker then distributes over what
survives — no stochastic revision guess that could conflict with the
pin and 503.

Bonus: this handles cross-axis edge cases better. If a request pins
`slice=s2` only, and one revision has no s2 pods:
  - previous rule: gating fires, weight-picks a revision, strict then
    narrows within it — if the picked revision has no s2 pods, 503.
  - new rule: gating skips, strict narrows all pods to slice=s2 (the
    revision with no s2 pods drops out naturally), picker uniform.
    Zero 503.

Rename: hasRevisionHeader → hasStrictHeader (matches the new logic).
Signed-off-by: Mathis Felardos <mathis@mistral.ai>

Author: hasB4K

pkg/epp/disaggregation/filter.go

@@ -105,8 +105,11 @@ func (f *gatingFilter) Filter(ctx context.Context, request *fwksched.InferenceRe
 		return append(make([]fwksched.Endpoint, 0, len(pods)), pods...)
 	}
 
-	// Fast path: header-pinned. Strict downstream will do the narrowing.
-	if f.hasRevisionHeader(request) {
+	// Fast path: any strict pin means the client has expressed a constraint.
+	// Strict downstream will narrow accordingly and the picker will
+	// distribute over what survives — no reason for gating to make a
+	// stochastic revision guess that could conflict with the pin.
+	if f.hasStrictHeader(request) {
 		return append(make([]fwksched.Endpoint, 0, len(pods)), pods...)
 	}
 
@@ -173,24 +176,22 @@ func crossRoleWeight(perRole map[string]int, required []string) int {
 	return total
 }
 
-// hasRevisionHeader reports whether the request carries the header that
-// pins the revision axis. Convention: the revision axis is the first
-// entry in Selectors — same source as controller.revisionLabelKey — and
-// only counts when it's a strict-mode selector (prefer mode is a hint,
-// not a pin).
-func (f *gatingFilter) hasRevisionHeader(request *fwksched.InferenceRequest) bool {
+// hasStrictHeader reports whether the request carries the header for any
+// strict-mode selector. Prefer-mode selectors are hints and don't count —
+// only a hard pin should suppress gating's weighted pick.
+func (f *gatingFilter) hasStrictHeader(request *fwksched.InferenceRequest) bool {
 	if request == nil {
 		return false
 	}
-	selectors := f.controller.config.Selectors
-	if len(selectors) == 0 {
-		return false
-	}
-	revSelector := selectors[0]
-	if revSelector.Mode != ModeStrict {
-		return false
+	for _, selector := range f.controller.config.Selectors {
+		if selector.Mode != ModeStrict {
+			continue
+		}
+		if request.Headers[selector.HeaderName] != "" {
+			return true
+		}
 	}
-	return request.Headers[revSelector.HeaderName] != ""
+	return false
 }
 
 // uniqueRevisions returns the set of distinct revision-label values in