feat(manifest-extends): field-merge same-name git-gate repos on extends

When a child bottle declares a git-gate repo with the same name as a
parent repo, merge field-by-field (child wins, parent provides fallback)
instead of letting the child entry silently replace the parent entry.
This lets a child override only `key:` without repeating `url:` and
`host_key:`. Change the merge key in _merge_git_remotes from UpstreamHost
to Name, which is the natural unique identity for a repo entry.

Closes #237

bot_bottle/manifest_extends.py

@@ -75,6 +75,11 @@ def _merge_bottles(
     from .manifest import ManifestBottle, ManifestGitUser
     from .manifest_egress import validate_egress_routes
 
+    # Before parsing the child, fill any git-gate repos that share a name
+    # with a parent repo: parent fields provide the default, child fields
+    # win on any field they declare (issue #237).
+    child_raw = _pre_merge_git_repos(parent.git, child_raw)
+
     # Parse the child's declared fields into a ManifestBottle (with the
     # usual defaults for anything missing). Validation runs the same
     # way it would for a leaf bottle: typos / wrong types die here.
@@ -130,6 +135,68 @@ def _merge_bottles(
     )
 
 
+def _entry_to_raw(entry: "ManifestGitEntry") -> dict[str, object]:
+    """Convert a ManifestGitEntry back to its raw YAML-equivalent dict."""
+    raw: dict[str, object] = {"url": entry.Upstream}
+    if entry.KnownHostKey:
+        raw["host_key"] = entry.KnownHostKey
+    key: dict[str, object] = {"provider": entry.Key.provider}
+    if entry.Key.provider == "static":
+        key["path"] = entry.Key.path
+    else:
+        key["forge_token_env"] = entry.Key.forge_token_env
+        if entry.Key.api_url:
+            key["api_url"] = entry.Key.api_url
+    raw["key"] = key
+    return raw
+
+
+def _pre_merge_git_repos(
+    parent_git: "tuple[ManifestGitEntry, ...]",
+    child_raw: dict[str, object],
+) -> dict[str, object]:
+    """Fill missing fields in same-named child git-gate repos from parent entries.
+
+    Returns a (potentially modified) copy of child_raw. For each repo in
+    child_raw that shares a name with a parent entry, the parent entry's
+    fields serve as defaults; child-declared fields win. Repos that appear
+    only in the parent or only in the child are left unchanged."""
+    from .manifest_util import as_json_object
+
+    git_raw = child_raw.get("git-gate")
+    if git_raw is None:
+        return child_raw
+    try:
+        git_obj = as_json_object(git_raw, "child git-gate")
+        repos_raw = git_obj.get("repos")
+        if repos_raw is None:
+            return child_raw
+        repos_obj = as_json_object(repos_raw, "child git-gate.repos")
+    except Exception:
+        return child_raw
+
+    parent_by_name = {entry.Name: entry for entry in parent_git}
+    if not any(rname in parent_by_name for rname in repos_obj):
+        return child_raw
+
+    merged_repos: dict[str, object] = {}
+    for repo_name, child_entry_raw in repos_obj.items():
+        if repo_name in parent_by_name:
+            parent_raw = _entry_to_raw(parent_by_name[repo_name])
+            try:
+                child_entry_obj = as_json_object(
+                    child_entry_raw, f"git-gate.repos[{repo_name!r}]"
+                )
+            except Exception:
+                merged_repos[repo_name] = child_entry_raw
+                continue
+            merged_repos[repo_name] = {**parent_raw, **child_entry_obj}
+        else:
+            merged_repos[repo_name] = child_entry_raw
+
+    return {**child_raw, "git-gate": {**git_obj, "repos": merged_repos}}
+
+
 def _child_declares_git_gate_repos(child_raw: dict[str, object]) -> bool:
     from .manifest_util import as_json_object
 
@@ -144,10 +211,10 @@ def _merge_git_remotes(
     parent: tuple[ManifestGitEntry, ...],
     child: tuple[ManifestGitEntry, ...],
 ) -> tuple[ManifestGitEntry, ...]:
-    by_host = {entry.UpstreamHost: entry for entry in parent}
+    by_name = {entry.Name: entry for entry in parent}
     for entry in child:
-        by_host[entry.UpstreamHost] = entry
-    return tuple(by_host.values())
+        by_name[entry.Name] = entry
+    return tuple(by_name.values())
 
 
 def _merge_egress(