Remove the Anthropic path; the gateway speaks one wire protocol

The platform now runs on Groq by default, through the OpenAI-compatible
chat-completions shape. That shape is not one vendor — Gemini, OpenRouter,
Together, vLLM and a local Ollama serve it too — so moving again stays
configuration rather than code.

Two things in the deleted file were not Anthropic's and would have gone
with it silently:

  withRetry / MaxAttempts / retryBackoff were defined in anthropic.go and
  CALLED BY openai.go. Deleting the file wholesale would have removed the
  retry policy of the provider that survived, and nothing in openai.go
  mentions it, so the loss would have been invisible until the next 429.
  The policy is a property of this platform's runs, not of a vendor's API;
  it now lives in retry.go where no provider can carry it off.

  StreamComplete had the same problem and moves to gateway.go, beside the
  Streamer interface whose comment already referenced it.

Three stale-configuration failures are now refused at startup instead of
being ignored. Each was verified firing through the real config.Load():

  MODEL_PROVIDER=anthropic — named separately from every other wrong value
  because it used to be correct. Ignoring it gives a stack that believes it
  is on Claude while every run goes to Groq and is billed there.

  ANTHROPIC_API_KEY set while MODEL_API_KEY is empty. Ignoring a key an
  operator did set is the worst version of this: they fail every run on a
  missing credential they are looking straight at.

  A leftover claude-* model id, naming the tier that carries it. This is
  the check the previous commit's error-detail work was diagnosing: such an
  id is accepted by this process, rejected by the provider, and 400s on
  EVERY run. "A model is wrong" does not say which of three lines to edit.

Defaults ship as a matched pair. defaultBaseURL and the three tier ids are
one decision, not four: an id is only meaningful against the service that
serves it, and a Groq id on an OpenAI base URL is the same failure from the
other side. The tiers also stop being one model — a tier whose cost does
not differ is a distinction that buys nothing.

Verified end to end against a stub of the wire, driving the real wiring
(config.Load in production mode, gateway.New, StreamComplete): streamed
deltas, tool-call decoding, the loopback credential exemption, and usage
totalling 150 rather than 190 — the cached-prefix subtraction still holds.

gofmt clean, go vet clean, 14/14 non-DB packages pass. httpserver still
needs a reachable database.

NOT verified: the I7 planted-injection eval. Removing this path removed the
only model whose refusal behaviour had been measured against it, so the new
default is unproven there until `make eval-live` runs with a real key. The
Groq model ids should also be confirmed against Groq's current lineup.
Flagged in CLAUDE.md §12 and docs/handover.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PJvibeSc1JYXjatankqM1g

go-api/internal/gateway/routing.go

@@ -4,26 +4,28 @@ import (
 	"github.com/krow/krow-backend/go-api/internal/config"
 )
 
-// Provider names the wire protocol a deployment talks.
+// ProviderOpenAI names the only wire protocol this platform speaks.
 //
-// Two, not two hundred: "anthropic" is the Claude API, and "openai" is the
-// chat-completions shape that Groq, Gemini, OpenRouter, Together, vLLM and
-// Ollama all serve. That second one is the reason this constant exists at all
-// — supporting those five providers is one implementation and five different
-// base URLs, and pretending otherwise would grow a package per vendor.
-const (
-	ProviderAnthropic = "anthropic"
-	ProviderOpenAI    = "openai"
-)
+// One constant, not an enum, because there is one implementation. "openai" is
+// the chat-completions shape — which is NOT only OpenAI. Groq, Gemini (through
+// its compatible endpoint), OpenRouter, Together, vLLM and a local Ollama all
+// serve it, and the difference between them is MODEL_BASE_URL and a model id,
+// nothing more. Supporting six vendors is one implementation and six base URLs.
+//
+// The Anthropic path was removed deliberately, not lost. `MODEL_PROVIDER=anthropic`
+// is now REFUSED at startup rather than ignored — see config.validateModel. A
+// deployment carrying the old value must be told it moved, because the silent
+// alternative is a stack that believes it is still on Claude while every run
+// goes somewhere else.
+const ProviderOpenAI = "openai"
 
 // Effort is how hard a tier is allowed to think.
 //
-// PROVIDER-NEUTRAL ON PURPOSE. This was `anthropic.OutputConfigEffort` until a
-// second provider existed, which meant the vendor's enum was baked into the
-// routing table that every provider has to read. Nothing was wrong with it
-// while there was one implementation; it became wrong the moment there were
-// two, because the OpenAI path would have had to import the Anthropic SDK to
-// learn how hard to think.
+// PROVIDER-NEUTRAL ON PURPOSE, and the reason that mattered is now history
+// worth keeping: this was a vendor SDK's own enum, baked into the routing table
+// every provider has to read. Making it the platform's own vocabulary is what
+// let that vendor be removed later without the routing table going with it —
+// a one-line deletion instead of a re-typing of every tier.
 //
 // The three values are the platform's own vocabulary. Each implementation maps
 // them onto whatever its API calls the same idea, and a provider with no such
@@ -55,8 +57,8 @@ type Routing struct {
 // Built once at startup from the environment and passed in frozen, per §10.
 // Nothing in this package reads the environment itself.
 type Config struct {
-	// Provider selects the implementation. Empty means anthropic, so a
-	// deployment that predates the second provider keeps working untouched.
+	// Provider selects the implementation. Empty means openai, which is now
+	// the only one; config.validateModel refuses any other value.
 	Provider string
 
 	APIKey string
@@ -116,21 +118,18 @@ func FromConfig(c config.ModelConfig) Config {
 
 // New builds the gateway a deployment's configuration asks for.
 //
-// The one place that maps a provider name to an implementation, so a caller
-// wires a gateway without knowing which vendor answers. An unrecognised
-// provider cannot reach here — config.validate rejects it at startup, where a
-// typo is one loud failure instead of one per run.
+// One provider, so this is a constructor rather than a choice. It survives the
+// removal of the second implementation because the runtime wires itself through
+// `gateway.New(gateway.FromConfig(...))` and should not learn a concrete type:
+// the next provider is a change here and nowhere else.
 func New(cfg Config) Gateway {
-	if cfg.Provider == ProviderOpenAI {
-		return NewOpenAI(cfg)
-	}
-	return NewAnthropic(cfg)
+	return NewOpenAI(cfg)
 }
 
 // routingFor resolves a tier against a table.
 //
-// Shared by both implementations: an unknown tier has already been normalised
-// by ParseTier, so the default arm is reached only by a zero value.
+// An unknown tier has already been normalised by ParseTier, so the default arm
+// is reached only by a zero value.
 func (c Config) routingFor(t Tier) Routing {
 	switch t {
 	case TierFast: