starlark_repository: add .local() tag class for on-disk repos

Lets MODULE.bazel point starlark_repository at a workspace-local path
instead of an http_archive. Useful when the source already lives on
disk — e.g. a git submodule — and we want to skip the network fetch
entirely. The bcr-frontend project hits this with ~449 overlay-bzl
modules that all derive from the same bazel-central-registry archive;
emitting one `.archive(urls=...)` per module trips GitHub's 429 rate
limit on cold caches.

Changes
- extensions/starlark_repository.bzl: new `local` tag class with attrs
  {name, path, build_directives, build_file_generation, languages,
  cfgs, imports, imports_out (default "imports.csv"), deleted_files,
  reresolve_known_proto_imports, importpath}. The extension impl maps
  user-facing `path` to the underlying `local_path` attr and dispatches
  to the same starlark_repository repo rule used by `.archive`.
- rules/proto/proto_repository.bzl: in `_proto_repository_impl`'s
  local_path branch, resolve workspace-relative paths against the main
  workspace root (via Label("@@//:MODULE.bazel").dirname) before
  passing them to ctx.watch_tree() and fetch_repo's --path arg. Bare
  strings were otherwise interpreted relative to the external repo's
  own dir, where the directory doesn't exist.
- rules/proto/proto_repository.bzl: in _generate_proto_repository_info,
  return empty string when imports_out is unset, so a future caller
  with no imports_out can't trip `exports_files([""])`.

Usage:

    starlark_repository = use_extension(
        "@build_stack_rules_proto//extensions:starlark_repository.bzl",
        "starlark_repository",
    )
    starlark_repository.local(
        name = "bzl.colordiff---1.0.22",
        path = "data/bazel-central-registry/modules/colordiff/1.0.22/overlay",
        build_directives = ["gazelle:starlarkrepository_root"],
        build_file_generation = "clean",
        languages = ["starlarkrepository"],
    )
    use_repo(starlark_repository, "bzl.colordiff---1.0.22")

Author: pcj

extensions/starlark_repository.bzl

@@ -40,12 +40,13 @@ def _extension_metadata(
     )
 
 def _starlark_repository_impl(module_ctx):
-    # named_repos is a dict<K,V> where V is the kwargs for the actual
-    # "starlark_repository" repo rule and K is the tag.name (the name given by the
-    # MODULE.bazel author)
+    # named_archives / named_locals are dicts<K,V> where V is the kwargs for
+    # the underlying "starlark_repository" repo rule and K is the tag.name
+    # (the name given by the MODULE.bazel author).
     named_archives = {}
+    named_locals = {}
 
-    # iterate all the module tags and gather a list of named_archives.
+    # iterate all the module tags and gather a list of named repos.
     #
     # TODO(pcj): what is the best practice for version selection here? Do I need
     # to check if module.is_root and handle that differently?
@@ -58,13 +59,28 @@ def _starlark_repository_impl(module_ctx):
                 if hasattr(tag, attr)
             }
             named_archives[tag.name] = kwargs
+        for tag in module.tags.local:
+            kwargs = {
+                attr: getattr(tag, attr)
+                for attr in _starlark_repository_local_attrs.keys()
+                if hasattr(tag, attr)
+            }
+            # The user-facing attr is "path"; the underlying repo rule expects
+            # "local_path" (a sibling of "urls" / "commit" / "version").
+            kwargs["local_path"] = kwargs.pop("path")
+            named_locals[tag.name] = kwargs
 
     # declare a repository rule foreach one
     for apparent_name, kwargs in named_archives.items():
         starlark_repository_repo_rule(
             apparent_name = apparent_name,
             **kwargs
         )
+    for apparent_name, kwargs in named_locals.items():
+        starlark_repository_repo_rule(
+            apparent_name = apparent_name,
+            **kwargs
+        )
 
     return _extension_metadata(
         module_ctx,
@@ -79,12 +95,40 @@ _starlark_repository_archive_attrs = starlark_repository_attrs | {
 }
 _starlark_repository_archive_attrs.pop("apparent_name")
 
+# Attrs for the .local() tag class. Excludes archive-only attrs (urls, sha256,
+# strip_prefix, type, integrity, canonical_id, auth_patterns, commit, tag,
+# vcs, remote, version, sum, replace) and instead takes a single `path`
+# (mapped to the underlying rule's `local_path`).
+_starlark_repository_local_attrs = {
+    "name": attr.string(
+        doc = "The repo name.",
+        mandatory = True,
+    ),
+    "path": attr.string(
+        doc = "Filesystem path (workspace-relative or absolute) to the repository contents.",
+        mandatory = True,
+    ),
+    "build_directives": attr.string_list(),
+    "build_file_generation": attr.string(),
+    "languages": attr.string_list(),
+    "cfgs": attr.label_list(allow_files = True),
+    "imports": attr.label_list(allow_files = True),
+    "imports_out": attr.string(default = "imports.csv"),
+    "deleted_files": attr.string_list(),
+    "reresolve_known_proto_imports": attr.bool(),
+    "importpath": attr.string(),
+}
+
 starlark_repository = module_extension(
     implementation = _starlark_repository_impl,
     tag_classes = dict(
         archive = tag_class(
             doc = "declare an http_archive repository that is post-processed by a custom version of gazelle that includes the 'protobuf' language",
             attrs = _starlark_repository_archive_attrs,
         ),
+        local = tag_class(
+            doc = "declare a local-path repository that is post-processed by gazelle's starlarkrepository language. Useful when the source already lives on disk (e.g. a git submodule) and we want to avoid network fetches.",
+            attrs = _starlark_repository_local_attrs,
+        ),
     ),
 )

rules/proto/proto_repository.bzl

@@ -84,16 +84,25 @@ def _proto_repository_impl(ctx):
 
     reproducible = False
     if ctx.attr.local_path:
+        # Resolve relative paths against the main workspace root. Bare strings
+        # passed to watch_tree() and the --path arg of fetch_repo are otherwise
+        # interpreted relative to the external repo's own directory, which is
+        # never what the caller wants.
+        local_path = ctx.attr.local_path
+        if not local_path.startswith("/"):
+            workspace_root = str(ctx.path(Label("@@//:MODULE.bazel")).dirname)
+            local_path = workspace_root + "/" + local_path
+
         if hasattr(ctx, "watch_tree"):
             # https://github.com/bazelbuild/bazel/commit/fffa0affebbacf1961a97ef7cd248be64487d480
-            ctx.watch_tree(ctx.attr.local_path)
+            ctx.watch_tree(local_path)
         else:
             # buildifier: disable=print
             print("""
   WARNING: go.mod replace directives to module paths is only supported in bazel 7.1.0-rc1 or later,
-          Because of this changes to %s will not be detected by your version of Bazel.""" % ctx.attr.local_path)
+          Because of this changes to %s will not be detected by your version of Bazel.""" % local_path)
 
-        fetch_repo_args = ["--path", ctx.attr.local_path, "--dest", ctx.path("")]
+        fetch_repo_args = ["--path", local_path, "--dest", ctx.path("")]
     elif ctx.attr.urls:
         # HTTP mode
         for key in ("commit", "tag", "vcs", "remote", "version", "sum", "replace"):
@@ -461,6 +470,8 @@ package_info(
     )
 
 def _generate_proto_repository_info(ctx):
+    if not ctx.attr.imports_out:
+        return ""
     return """
 exports_files(["{imports_out}"])
 """.format(