fix: payload C headers via -idirafter for GCC (include_next reachability)

Ground truth from CI (command now in the error): -isystem'd payload glibc
include was present yet #include_next <stdlib.h> still failed. GCC's
libstdc++ wraps libc headers with #include_next, which only searches
directories AFTER the current header's dir — gcc's built-in dirs are last,
so -isystem (inserted before them) is unreachable. Use -idirafter (appended
to the very end) for GCC payload headers in both the std-module precompile
and per-TU flags; clang keeps -isystem. Verified with a faithful fresh-home
repro (no subos => invalid sysroot): first-run installs glibc default and
builds clean.

Author: d2learn-org

src/build/flags.cppm

@@ -173,11 +173,18 @@ CompileFlags compute_flags(const BuildPlan& plan) {
         }
         f.sysroot = link_toolchain_flags;
     } else if (plan.toolchain.payloadPaths) {
-        // No sysroot but have payload paths: use -isystem.
+        // No usable sysroot: wire the C library headers from the payload.
+        // For GCC use -idirafter (appended after the built-in dirs) so that
+        // libstdc++'s #include_next wrappers can reach them; -isystem would
+        // place them BEFORE the built-ins, invisible to #include_next.
         auto& pp = *plan.toolchain.payloadPaths;
-        compile_toolchain_flags += " -isystem" + escape_path(pp.glibcInclude);
+        const bool clangTc = mcpp::toolchain::is_clang(plan.toolchain);
+        auto inc_flag = [&](const std::filesystem::path& p) {
+            return (clangTc ? " -isystem" : " -idirafter") + escape_path(p);
+        };
+        compile_toolchain_flags += inc_flag(pp.glibcInclude);
         if (!pp.linuxInclude.empty())
-            compile_toolchain_flags += " -isystem" + escape_path(pp.linuxInclude);
+            compile_toolchain_flags += inc_flag(pp.linuxInclude);
     }
 
     // Binutils -B flag

src/toolchain/stdmod.cppm

@@ -236,10 +236,21 @@ std::expected<StdModule, StdModError> ensure_built(
                 sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->linuxInclude.string());
         }
     } else if (tc.payloadPaths) {
-        // No sysroot: use payload -isystem paths.
-        sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->glibcInclude.string());
+        // No usable sysroot: wire the C library headers from the payload.
+        // GCC's libstdc++ wraps libc headers via #include_next, which only
+        // searches directories AFTER the one the current header came from —
+        // and gcc's built-in dirs are LAST in the search order, so an
+        // -isystem payload dir (inserted before the built-ins) is unreachable
+        // from #include_next. -idirafter appends the payload to the very end,
+        // exactly where #include_next looks.
+        const bool clang = is_clang(tc);
+        auto add_inc = [&](const std::filesystem::path& p) {
+            if (clang) sysroot_flag += std::format(" -isystem'{}'", p.string());
+            else       sysroot_flag += std::format(" -idirafter'{}'", p.string());
+        };
+        add_inc(tc.payloadPaths->glibcInclude);
         if (!tc.payloadPaths->linuxInclude.empty())
-            sysroot_flag += std::format(" -isystem'{}'", tc.payloadPaths->linuxInclude.string());
+            add_inc(tc.payloadPaths->linuxInclude);
     }
 
     std::vector<std::string> stdCommands;