fix: emit absolute -fprebuilt-module-path so clangd resolves modules

src/build/flags.cppm was emitting a bare `-fprebuilt-module-path=pcm.cache`
(or `=gcm.cache`). This works for `mcpp build` because ninja runs commands
with cwd = `<projectRoot>/target/<triple>/<fp>/` so the relative path
resolves correctly. But the same flag is captured verbatim into
`compile_commands.json`, whose `directory` field is `plan.projectRoot`.
Per CDB spec, clangd does `cd <directory>` before resolving the args, so
it looks for `<projectRoot>/pcm.cache` — which doesn't exist. Effect:
`import` resolution silently fails in clangd ("module 'X' not found"),
even when `mcpp build` succeeds.

The other `-fmodule-file=` flags in the same block were already absolute
(escape_path-wrapped); this one was an oversight.

Fix: format the flag with `escape_path(plan.outputDir / traits.bmiDir)`.
Single line. ninja still works (absolute paths are cwd-independent), and
clangd now finds the BMI cache.

Regression test: tests/e2e/47_cdb_prebuilt_module_path_abs.sh creates a
fresh project, runs `mcpp build`, parses `compile_commands.json`, asserts
every `-fprebuilt-module-path=X`:
  - is absolute (starts with `/` on POSIX or `<drive>:` on Windows)
  - ends in `/pcm.cache` or `/gcm.cache`
  - points to an existing directory
Pass-through for GCC-only flows that don't emit the flag at all.

Author: Sunrisepeak

src/build/flags.cppm

@@ -212,7 +212,17 @@ CompileFlags compute_flags(const BuildPlan& plan) {
     auto traits = mcpp::toolchain::bmi_traits(plan.toolchain);
     std::string prebuilt_module_flag;
     if (traits.needsPrebuiltModulePath) {
-        prebuilt_module_flag = std::format(" -fprebuilt-module-path={}", traits.bmiDir);
+        // Absolute path: a bare `pcm.cache` / `gcm.cache` works at ninja
+        // time because ninja runs commands with cwd = outputDir, but the
+        // same flag ends up verbatim in `compile_commands.json` whose
+        // `directory` field is the project root. clangd does `cd directory`
+        // before resolving the flag, so a bare relative path points at
+        // `<projectRoot>/pcm.cache` (which doesn't exist) and `import`
+        // resolution fails with `module 'X' not found`. The other
+        // `-fmodule-file=` flags in this block are already escape_path'd
+        // (absolute) for the same reason — this one was a leftover.
+        prebuilt_module_flag = std::format(" -fprebuilt-module-path={}",
+            escape_path(plan.outputDir / traits.bmiDir));
     }
     f.cxx = std::format("-std=c++23{}{}{}{}{}{}{}{}{}{}", module_flag, std_module_flag,
                         std_compat_module_flag, prebuilt_module_flag,

tests/e2e/47_cdb_prebuilt_module_path_abs.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# requires:
+# 47_cdb_prebuilt_module_path_abs.sh — `-fprebuilt-module-path` in
+# compile_commands.json must be an ABSOLUTE path, not a bare `pcm.cache` /
+# `gcm.cache`. Reason: CDB `directory` is the project root, but ninja runs
+# from the outputDir; a bare relative path works at build time only and
+# silently breaks clangd's module resolution ("module 'X' not found").
+set -e
+
+TMP=$(mktemp -d)
+trap "rm -rf $TMP" EXIT
+
+cd "$TMP"
+"$MCPP" new app > /dev/null
+cd app
+"$MCPP" build > /dev/null
+
+cdb=compile_commands.json
+[[ -f "$cdb" ]] || { echo "FAIL: no $cdb generated"; exit 1; }
+
+# Extract every -fprebuilt-module-path=<value> token.
+# (No jq dependency — grep is enough and portable on macOS / git-bash.)
+vals=$(grep -oE '\-fprebuilt-module-path=[^"]+' "$cdb" | sed 's/^-fprebuilt-module-path=//')
+if [[ -z "$vals" ]]; then
+    # No -fprebuilt-module-path emitted = GCC toolchain that uses -fmodules
+    # only (gcm.cache). bmi_traits sets needsPrebuiltModulePath=false for
+    # the GCC path. Nothing to assert — pass.
+    echo "OK (no prebuilt-module-path flag — GCC toolchain)"
+    exit 0
+fi
+
+# Every value must be absolute AND point at the actual build cache dir.
+fail=0
+while read -r v; do
+    [[ -z "$v" ]] && continue
+    echo "  checking: $v"
+
+    # Absolute path test: leading '/' on POSIX or '<letter>:' on Windows.
+    if [[ "$v" =~ ^/ || "$v" =~ ^[A-Za-z]: ]]; then
+        :
+    else
+        echo "FAIL: -fprebuilt-module-path value is relative: '$v'"
+        echo "  this breaks clangd because CDB 'directory' = project root,"
+        echo "  but the BMI cache lives under target/<triple>/<fp>/."
+        fail=1
+    fi
+
+    # Must end with pcm.cache or gcm.cache (sanity).
+    case "$v" in
+        */pcm.cache|*/gcm.cache) ;;
+        *)  echo "FAIL: -fprebuilt-module-path value does not end in pcm.cache/gcm.cache: '$v'"
+            fail=1 ;;
+    esac
+done <<< "$vals"
+
+[[ $fail -eq 0 ]] || exit 1
+
+# Stronger: clangd would `cd` into CDB's directory then resolve. Verify the
+# value, taken at face value (already absolute), points at a real dir.
+first=$(echo "$vals" | head -1)
+if [[ ! -d "$first" ]]; then
+    echo "FAIL: -fprebuilt-module-path resolves to a non-existent dir: $first"
+    echo "  (build succeeded, so the BMI dir must exist somewhere — this"
+    echo "   means the flag points to the wrong place even with abs path.)"
+    exit 1
+fi
+
+echo "OK"