refactor: ein Binary — talk startet den Daemon selbst, talkd und Degraded Mode entfallen

Zwei Binaries erzeugten den halben Komplexitätsballast: Degraded Mode mit
Lock-Datei und Stale-Lock-Race, „läuft talkd?", Autostart-Konfiguration je
OS, doppelte Chain-Konstruktion in cmd/talk und cmd/talkd — und der
Degraded Mode kannte weder Rate-Limit noch Ruhezeiten.

Jetzt:
- internal/speak: der eine Sprech-Kern (Config + Sink + Kette → Ansage);
  Daemon und Direkt-Pfad benutzen ihn, es gibt keine zweite
  Zusammensetzung der Kette mehr.
- internal/daemon: Run (der bisherige talkd-Kern), Spawn (detached per
  Setsid bzw. DETACHED_PROCESS, stdout/stderr → daemon.log), PID-Datei
  daemon.pid, Shutdown-Trigger.
- `talk daemon run|start|stop`: Vordergrund (systemd/launchd), expliziter
  Hintergrund-Start, Stop per POST /shutdown — stop wartet, bis HTTP weg
  und die PID-Datei gelöscht ist (Prozess wirklich beendet).
- Autostart: say/wrap starten den Daemon beim ersten Sprechbefehl selbst
  (daemon.autostart, Default an; Env TALK_AUTOSTART). Verliert ein
  paralleler Aufruf das Port-Rennen, erkennt er das am Kind-Ende und nutzt
  den Daemon des anderen — kein Timeout-Warten.
- Direkt-Pfad statt Degraded Mode: ohne erreichbaren oder startbaren
  Daemon spricht talk direkt (Mute respektiert, kein Lock, Hinweis +
  Grund + Log-Pfad auf stderr). Steuerbefehle starten den Daemon bewusst
  nicht; `talk status` zeigt „läuft nicht" (Exit 1).
- cmd/talkd und cmd/talk/degraded.go entfernt; README-Daemon-Abschnitt
  neu.

Tests: Harness baut nur noch talk und startet `talk daemon run`;
TALK_AUTOSTART=false als Grundausstattung aller Tests (kein Test
hinterlässt Daemons), autostart_test.go schaltet es bewusst an: Autostart
beim ersten say, Idempotenz, paralleler Start in EINE Queue, expliziter
start/stop, Port fremd belegt → Direkt-Pfad ohne Timeout. Cross-Compile
aller sechs Targets mit CGO_ENABLED=0 verifiziert.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

internal/config/config.go

@@ -44,6 +44,9 @@ type Config struct {
 	// Queue steuert die Anti-Spam-Gesetze des Daemons (Task 05).
 	Queue Queue `toml:"queue"`
 
+	// Daemon steuert den Hintergrundprozess (Autostart).
+	Daemon Daemon `toml:"daemon"`
+
 	// Provider pinnt die Kette auf genau einen Provider (z. B.
 	// `provider = "elevenlabs"`); leer = komplette Default-Kette
 	// (elevenlabs → openai → edge → osbuiltin). Das CLI-Flag --provider
@@ -99,6 +102,15 @@ type Server struct {
 	AllowedOrigins []string `toml:"allowed_origins"`
 }
 
+// Daemon sind die Einstellungen des Hintergrundprozesses (TOML `[daemon]`).
+type Daemon struct {
+	// Autostart lässt talk den Daemon beim ersten Sprechbefehl selbst im
+	// Hintergrund starten (Default true; Env TALK_AUTOSTART). false ist für
+	// Setups, die den Daemon selbst verwalten (systemd, launchd, Task
+	// Scheduler): say spricht dann ohne Daemon direkt, mit Hinweis.
+	Autostart bool `toml:"autostart"`
+}
+
 // Wrap sind die Einstellungen von `talk wrap` (TOML `[wrap]`).
 type Wrap struct {
 	// Label ersetzt den Basisnamen des Befehls in der Ansage — z. B.
@@ -137,6 +149,7 @@ func Defaults() Config {
 		Audio:     Audio{Sink: SinkOto},
 		Server:    Server{Port: DefaultServerPort},
 		Queue:     Queue{RateLimit: DefaultRateLimit, AllowHighBurst: true},
+		Daemon:    Daemon{Autostart: true},
 		QuietMode: queue.QuietModeDiscard,
 	}
 }
@@ -210,6 +223,13 @@ func applyEnv(cfg Config, getenv func(string) string) (Config, error) {
 			cfg.Server.AllowedOrigins = origins
 		}
 	}
+	if v := getenv("TALK_AUTOSTART"); v != "" {
+		b, err := strconv.ParseBool(v)
+		if err != nil {
+			return cfg, fmt.Errorf("TALK_AUTOSTART: ungültiger Wert %q (true/false)", v)
+		}
+		cfg.Daemon.Autostart = b
+	}
 	if v := getenv("TALK_WRAP_LABEL"); v != "" {
 		cfg.Wrap.Label = v
 	}

internal/config/config_test.go

@@ -686,3 +686,48 @@ allow_high_burst = false
 		}
 	})
 }
+
+// TestLoadDaemonAutostart deckt [daemon] autostart ab: Default an, TOML
+// kann es ausschalten, Env TALK_AUTOSTART schlägt die Datei, Unsinn ist ein
+// klarer Fehler.
+func TestLoadDaemonAutostart(t *testing.T) {
+	fehlendeDatei := filepath.Join(t.TempDir(), "gibt-es-nicht.toml")
+	writeTOML := func(t *testing.T, content string) string {
+		path := filepath.Join(t.TempDir(), "config.toml")
+		if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		return path
+	}
+
+	cfg, err := Load(Options{File: fehlendeDatei, Getenv: env(nil)})
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if !cfg.Daemon.Autostart {
+		t.Error("Daemon.Autostart = false, want Default true")
+	}
+
+	cfg, err = Load(Options{File: writeTOML(t, "[daemon]\nautostart = false\n"), Getenv: env(nil)})
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if cfg.Daemon.Autostart {
+		t.Error("Daemon.Autostart = true, want false aus TOML")
+	}
+
+	cfg, err = Load(Options{
+		File:   writeTOML(t, "[daemon]\nautostart = false\n"),
+		Getenv: env(map[string]string{"TALK_AUTOSTART": "true"}),
+	})
+	if err != nil {
+		t.Fatalf("Load: %v", err)
+	}
+	if !cfg.Daemon.Autostart {
+		t.Error("Daemon.Autostart = false, want true aus Env (Env schlägt Datei)")
+	}
+
+	if _, err := Load(Options{File: fehlendeDatei, Getenv: env(map[string]string{"TALK_AUTOSTART": "vielleicht"})}); err == nil {
+		t.Error("TALK_AUTOSTART=vielleicht: kein Fehler, want klarer Fehler")
+	}
+}