Add runtime overrides --bcce-threads and --bcce-output-dir

Make the macro-level `max_threads` and `output_dir` settings overridable
at runtime via flags after the `--` separator on `bazel run`. Precedence
is runtime flag > macro param > default.

* `--bcce-threads=N` plugs into the existing `_threads()` helper that
  feeds `ProcessPoolExecutor(max_workers=...)`. Invalid values warn and
  fall through to the macro/default.
* `--bcce-output-dir=DIR` is consulted via a new `_output_dir()` helper
  used by the `compile_commands.json` write path.

README's "Customizing the compile_commands.json generation" section
gains entries for both flags.

Same `--bcce-*` pattern as hedronvision#122; same precedence rule.

Author: helly25

README.md

@@ -191,6 +191,8 @@ The tool has a few parameters that control output generation:
 * `--bcce-color[=`_auto_`]` — Enable or disable colored output. Useful for environments where the color codes are not handled (e.g. the VSCode OUTPUT window). With the default `auto`, the environment is consulted (both [`NO_COLOR`](https://no-color.org) and `TERM`). To force off, use `0`/`no`, or pass `--nobcce-color`. To force on, use `1`/`yes`.
 * `--bcce-compiler[=`_compiler_`]` — Override the detected compiler. Useful if the compiler found in the editor environment is different from the one that should appear in `compile_commands.json`. May interfere with cross-compilation. If the goal is to retarget `clangd`, the [clangd compileflags](https://clangd.llvm.org/config#compileflags) config can do this on the `clangd` side instead.
 * `--bcce-copt[=`_option_`]` — Pass an additional `option` to every arg list in `compile_commands.json` (can be repeated). As above, you can also do this on the `clangd` side via compileflags.
+* `--bcce-threads[=`_N_`]` — Override the worker-pool size for one run. Falls back to the macro `max_threads`, then the executor default (`os.cpu_count()`).
+* `--bcce-output-dir[=`_dir_`]` — Override the directory `compile_commands.json` is written to. Falls back to the macro `output_dir`, then the workspace root.
 
 As with options passed through to `bazel aquery`, these flags must be separated from the bazel invocation by `--`. For example, to suppress colored output:
 

refresh.template.py

@@ -54,13 +54,32 @@ def _bazel():
 
 
 def _threads():
-    """User-requested worker pool size, or the executor default if unset."""
+    """Worker pool size: --bcce-threads > macro `max_threads` > executor default.
+
+    Returning `None` lets ProcessPoolExecutor pick its own default
+    (os.cpu_count(), which becomes os.process_cpu_count() on Python 3.13+).
+    """
+    runtime = _get_last_arg('bcce-threads')
+    if runtime:
+        try:
+            n = int(runtime)
+            if n > 0:
+                return n
+        except ValueError:
+            pass
+        log_warning(f">>> Ignoring invalid --bcce-threads={runtime!r}; must be a positive integer.")
     user_max_threads = {max_threads}
-    # `None` lets ProcessPoolExecutor pick its own default (os.cpu_count(),
-    # which becomes os.process_cpu_count() on Python 3.13+).
     return user_max_threads if user_max_threads else None
 
 
+def _output_dir():
+    """Output directory: --bcce-output-dir > macro `output_dir` > workspace root."""
+    runtime = _get_last_arg('bcce-output-dir')
+    if runtime is not None:
+        return runtime
+    return {output_dir}
+
+
 @functools.lru_cache(maxsize=None)
 def _non_bcce_args():
     """Returns `sys.argv[1:]` with all bcce args removed."""
@@ -1564,8 +1583,8 @@ def main():
     There should be actionable warnings, above, that led to this.""")
         sys.exit(1)
 
-    # Resolve the output path; `output_dir` is the macro parameter (empty == cwd).
-    output_path = os.path.join({output_dir}, 'compile_commands.json')
+    # Resolve the output path: `--bcce-output-dir` flag > macro `output_dir` > workspace root.
+    output_path = os.path.join(_output_dir(), 'compile_commands.json')
 
     # Remove any existing compile_commands.json before opening; handles the common
     # case where it's a symlink (e.g. pointing into a cmake build dir), which would