feat(scheduler): separate image-generation AUTO chain with UI toggle

Image models previously could not be scheduled through a priority
chain: the chat AUTO chain explicitly skips image-kind slots, and
AUTO image requests fell back to unordered registry discovery.

- config: add auto_image rules (auto_image yaml / image_rules json);
  legacy auto rules keep their meaning as the chat chain
- core: buildAutoImageChain mirrors buildAutoChain with inverted kind
  filter (image-only); SaveAutoImageRules + AutoImageRules/AutoImageChain
- scheduler: ChainImage walks the chain tier-by-tier with round-robin
  and preference ordering, skipping cooling slots
- gateway: handleImage AUTO now runs down AutoImageChain when one is
  configured (falls back to legacy discovery otherwise) and records
  the actual served model; handleAutoAPI GET returns image_rules and
  PUT accepts image_rules independently of rules
- webui: priority page gains a chat/image toggle editing two
  independent lane sets; add-slot picker filters by active kind;
  persistAuto writes only the active chain's field

internal/gateway/chat.go

@@ -897,11 +897,45 @@ func (g *Gateway) handleImage(w http.ResponseWriter, r *http.Request) {
 	if model == "" {
 		model = g.core.DefaultModel()
 	}
-	if !isAuto(model) {
-		if allow := g.allowedModels(r.Context()); allow != nil && !g.hasScopeModel(allow, model) {
-			writeError(w, http.StatusForbidden, "model_not_allowed", fmt.Sprintf("model %q is not allowed for this key", model))
+	if isAuto(model) {
+		if chain := g.core.AutoImageChain(); chain != nil && len(chain.Tiers) > 0 {
+			if msg := g.checkModelScope(r.Context(), "AUTO"); msg != "" {
+				writeError(w, http.StatusForbidden, "model_not_allowed", msg)
+				return
+			}
+			done := g.stats.Begin()
+			defer done()
+			rec := &Req{Key: keyID(reqKey(r.Context())), Type: "image", Model: model, OK: false}
+			t0 := time.Now()
+			resp, usedSrc, usedModel, err := g.core.Scheduler().ChainImage(r.Context(), chain, &req)
+			rec.LatMs = time.Since(t0).Milliseconds()
+			if err != nil {
+				rec.Status = upstreamErrStatus(err)
+				rec.Err = err.Error()
+				g.writeRec(rec)
+				writeError(w, rec.Status, "upstream_error", clientUpstreamErr(err))
+				return
+			}
+			rec.Source = usedSrc
+			if usedModel != "" {
+				rec.Model = usedModel // actual image model served, not "AUTO"
+			}
+			rec.OK = true
+			rec.Status = http.StatusOK
+			rec.Compl = int64(len(resp.ImageData))
+			g.writeRec(rec)
+			writeJSON(w, http.StatusOK, types.ImageGenResponse{
+				Created: time.Now().Unix(),
+				Data:    resp.ImageData,
+			})
 			return
 		}
+		// no image chain configured: fall through to legacy discovery (all
+		// sources exposing an image model, tried in registry order)
+	}
+	if allow := g.allowedModels(r.Context()); allow != nil && !g.hasScopeModel(allow, model) {
+		writeError(w, http.StatusForbidden, "model_not_allowed", fmt.Sprintf("model %q is not allowed for this key", model))
+		return
 	}
 	cands, _ := g.resolveByModel(model)
 	cands = imageOnly(cands)