CB-108: worker placement — one tab per worker in a dedicated worker space

Workers now land in their own herdr tab inside a dedicated, shared "worker
space" (workspace.create → tab.create → agent.start{tab_id} → close seed shell
→ rename), instead of splitting the user's currently-focused tab. Placement is
configurable (worker.placement tab|pane, worker.workspace, worker.tabLabel);
a future per-session space is just a distinct label.

New: Workspace/Tab records, WorkspaceControl over workspace.*/tab.*,
AgentControl.start tab_id overload, Agent.tabId.

Lifecycle carefulness:
- ensureWorkspace is a synchronized find-or-create (never double-creates)
- teardown closes the tab ONLY when the worker is its sole pane (never a
  shared user tab), resolving the tab via pane.get before closing
- tolerance is precise: only *_not_found is swallowed; real failures surface
- spawn failure closes the orphan tab; post-start cosmetic steps can't orphan
  a live worker or fail the spawn
- unique per-worker names (claude-<profile>-<nonce>-<seq>) with retry: herdr
  rejects duplicate agent names, and the per-process nonce survives a restart
  with lingering workers

herdr facts pinned: agent.start honors tab_id; agent name must be unique;
kind/status are detected from terminal output, not the name.

Reviewed at high effort (multi-agent); all findings addressed. 34 tests green
(29 unit/acceptance + 5 contract vs live herdr 0.7.0). Also bumps wiki.

bridged/src/main/java/dev/ltms/bridged/config/BridgedConfig.java

@@ -45,13 +45,41 @@ public record BridgedConfig(
      * @param tokenEnv  name of the host env var holding the worker's auth token; its value
      *                  is injected as {@code ANTHROPIC_AUTH_TOKEN} (never stored in config)
      * @param argv      launch command; defaults to {@code ["claude"]}
+     * @param placement where a worker lands: {@code "tab"} (default — its own tab in the
+     *                  worker space) or {@code "pane"} (legacy — split the focused tab)
+     * @param workspace label of the dedicated worker space; found-or-created on first
+     *                  spawn (default {@code "bridged-workers"}). A future per-session
+     *                  layout is just a distinct label here — the shared space is default.
+     * @param tabLabel  template for a worker tab's label; {@code {profile}}/{@code {model}}
+     *                  and {@code {n}} (per-worker number, to keep sibling tabs distinct)
+     *                  are substituted (default {@code "worker: {profile} #{n}"})
      */
     @JsonIgnoreProperties(ignoreUnknown = true)
     public record Worker(String profile, String baseUrl, String model,
-                         String configDir, String tokenEnv, List<String> argv) {
+                         String configDir, String tokenEnv, List<String> argv,
+                         String placement, String workspace, String tabLabel) {
         public Worker {
             argv = (argv == null || argv.isEmpty()) ? List.of("claude") : List.copyOf(argv);
             tokenEnv = (tokenEnv == null || tokenEnv.isBlank()) ? "BRIDGED_WORKER_TOKEN" : tokenEnv;
+            placement = (placement == null || placement.isBlank()) ? "tab" : placement.toLowerCase();
+            workspace = (workspace == null || workspace.isBlank()) ? "bridged-workers" : workspace;
+            tabLabel = (tabLabel == null || tabLabel.isBlank()) ? "worker: {profile} #{n}" : tabLabel;
+        }
+
+        /** True when workers should land in their own tab in the worker space. */
+        public boolean tabPlacement() {
+            return "tab".equals(placement);
+        }
+
+        /**
+         * Render {@link #tabLabel} for the {@code n}-th worker (substitutes
+         * {@code {profile}}/{@code {model}}/{@code {n}}), so sibling worker tabs are distinct.
+         */
+        public String renderTabLabel(long n) {
+            return tabLabel
+                    .replace("{profile}", profile == null ? "" : profile)
+                    .replace("{model}", model == null ? "" : model)
+                    .replace("{n}", Long.toString(n));
         }
     }