[proxy] normalize Vertex model ids in routing, guardrail, and token counting

Vertex requests reach the router/guardrail with the "@version" suffix
already stripped from the URL model by the request parser, but the
operator-facing config may carry the raw versioned id the Google console
documents (e.g. "claude-opus-4-6@20250514"):

- a Vertex provider registered with versioned model ids denied every
  request as model_not_routable (the Vertex analog of the Bedrock gap
  fixed in #6773), and
- a guardrail allowlist entry with a versioned id never matched, denying
  the model as model_blocked.

Both bit a customer driving Anthropic-on-Vertex through the agent
network with unversioned model ids (…/models/claude-opus-4-6:rawPredict
at the global location).

Introduce a shared llm.NormalizeVertexModel (the same "@" stripping the
parser already does) and apply it to a Vertex route's candidate models in
routeClaimsModel and to guardrail allowlist entries, so either spelling
of the same model matches. Non-Vertex routes and entries without "@"
keep exact matching.

Also resolve the real model for the Vertex token-count endpoint:
…/models/count-tokens:rawPredict carries the literal "count-tokens"
pseudo-model in the URL and the actual model in the body (Claude Code
sends one such call per request), so any configured allowlist denied all
token counting. The parser now reads the body model for that endpoint;
an unreadable body keeps the pseudo-model and fails closed.

proxy/internal/middleware/builtin/llm_request_parser/middleware.go

@@ -253,9 +253,7 @@ func parseVertexPath(reqPath string) (vertexRequest, bool) {
 	if c := strings.LastIndex(rest, ":"); c >= 0 {
 		model, action = rest[:c], rest[c+1:]
 	}
-	if at := strings.Index(model, "@"); at >= 0 {
-		model = model[:at]
-	}
+	model = llm.NormalizeVertexModel(model)
 	if model == "" {
 		return vertexRequest{}, false
 	}
@@ -276,24 +274,40 @@ func vertexPublisherVendor(publisher string) string {
 	}
 }
 
+// vertexCountTokensModel is the pseudo-model of the Vertex token-count endpoint,
+// the one Vertex shape whose real model lives in the body, not the URL path.
+const vertexCountTokensModel = "count-tokens"
+
 // invokeVertex emits the model/vendor/session/prompt for a Vertex publisher
 // request, using the publisher's parser to read the (vendor-native) body.
 func (m middlewareImpl) invokeVertex(in *middleware.Input, vx vertexRequest) *middleware.Output {
 	out := &middleware.Output{Decision: middleware.DecisionAllow}
 	vendor := vertexPublisherVendor(vx.publisher)
 
-	md := []middleware.KV{}
-	if vendor != "" {
-		md = append(md, middleware.KV{Key: middleware.KeyLLMProvider, Value: vendor})
-	}
-	md = append(md, middleware.KV{Key: middleware.KeyLLMModel, Value: vx.model})
-	md = append(md, middleware.KV{Key: middleware.KeyLLMStream, Value: strconv.FormatBool(vx.stream)})
-
 	var parser llm.Parser
 	if vendor != "" {
 		parser, _ = llm.ParserByName(vendor)
 	}
 
+	model := vx.model
+	// count-tokens carries its real model in the body; resolve it so the
+	// guardrail and router evaluate the actual model. An unreadable body keeps
+	// the pseudo-model and fails closed downstream.
+	if model == vertexCountTokensModel && parser != nil {
+		if facts, err := parser.ParseRequest(in.Body); err == nil && facts.Model != "" {
+			if bodyModel := llm.NormalizeVertexModel(facts.Model); bodyModel != "" {
+				model = bodyModel
+			}
+		}
+	}
+
+	md := []middleware.KV{}
+	if vendor != "" {
+		md = append(md, middleware.KV{Key: middleware.KeyLLMProvider, Value: vendor})
+	}
+	md = append(md, middleware.KV{Key: middleware.KeyLLMModel, Value: model})
+	md = append(md, middleware.KV{Key: middleware.KeyLLMStream, Value: strconv.FormatBool(vx.stream)})
+
 	sessionID := sessionIDFromHeaders(in.Headers)
 	if sessionID == "" && parser != nil {
 		sessionID = parser.ExtractSessionID(in.Body)