feat(model-routing): add per-call selection, strategies, and ordered fallback

[JackYPCOnline]

Description

Phase C of model routing, stacked on Phase B (feature/model-routing-core). Where Phase B resolves a single model at construction, this adds per-call selection and ordered fallback, matching the P0 "router core and fallback" + local strategy items in the design (team/designs/0016-model-routing.md).

A RoutingStrategy chooses a candidate per model call; a selection middleware runs it once per invocation (cached in invocation_state), sets the per-call model, and is registered before the agentic capability middleware. Independently, the router installs an ordered-fallback hook: when the selected model's retries are exhausted, it advances to the next untried candidate in declaration order and requests another attempt. This composes with the existing ModelRetryStrategy rather than replacing it.

Public API (provisional; package is internal pending API review)

from strands.models.routing import ModelRouter, RoutingCandidate, FallbackStrategy, ContextFitStrategy

# Ordered fallback (default strategy): try sonnet, fall over to opus on failure.
agent = Agent(model=ModelRouter(models=[sonnet, opus]))

# Capacity-based local selection.
agent = Agent(model=ModelRouter(models=[haiku, sonnet, opus], strategy=ContextFitStrategy()))

• RoutingStrategy (Protocol): async select(context) -> RoutingCandidate; the result must be one of the candidates.
• RoutingContext: messages, system_prompt, tool_specs, candidates, invocation_state.
• ModelRouter(models, *, strategy=None) — strategy defaults to FallbackStrategy (selects the first candidate). Selection recurses into nested routers.
• Ordered fallback is always active, under any strategy: on an unretried model failure the router advances through untried candidates in declaration order, resetting the retry budget each hop, until one succeeds or all are exhausted.
• Bundled strategies: FallbackStrategy (select-first) and ContextFitStrategy — routes by capacity, estimating tokens with each candidate's own count_tokens and treating a candidate as fitting when usage stays within threshold of its window (default: the conversation manager's DEFAULT_COMPRESSION_THRESHOLD, so a fit won't immediately trip proactive compression). Picks the smallest fitting window, the largest when none fit; reuses the shared DEFAULT_CONTEXT_WINDOW_LIMIT for models with no declared window and is best-effort if a count fails.

Follow-ups (not in this PR)

• Model-driven routing (Phase D): a judge model classifies the request and names a candidate.
• P1: cost-aware, cache-affinity (sticky), classifier/semantic.

Notes

Stacked on feature/model-routing-core; review that PR first. Adds one small change to shared retry code (ModelRetryStrategy.reset()) so the router can reset the retry budget when advancing. Integration tests (real Bedrock) cover context-fit selection and fallback past a broken model.

Draft: per-call selection + ordered fallback, pending API review and the model-driven follow-up.