A build program's environment contract does not depend on the children mcpp has launched (#797)

On Windows a child's environment is applied to mcpp itself (`_putenv_s`), and
`build_env_for_cl` composed the toolset's PATH from the process's current
PATH. The value reached `MCPP_TOOL_ENV`, part of a build program's run key: a
build that had compiled its programs through the build programs' graph ran
ninja first, so its PATH carried the toolset's directory once more than the
next build's, and every program ran again (e2e 89, 839, 842; mcpp-plugins
cmake-consumer). The toolset's PATH and a program's PATH now start from the
PATH the process was started with (`env::inherited_path`), captured before
anything is launched.

Author: Sunrisepeak

modules/platform/src/env.cppm

@@ -79,6 +79,11 @@ private:
 };
 
 std::string path_list_separator();
+// The PATH this process was started with. On Windows a child's environment is
+// applied to this process (`_putenv_s`), so `getenv("PATH")` answers what the
+// children launched so far were given; a value that must not depend on that --
+// an environment a build program's run is keyed on -- starts from this one.
+const std::string& inherited_path();
 std::string runtime_library_path_key();
 std::string host_tool_runtime_library_path_key();
 
@@ -114,6 +119,16 @@ std::string build_env_prefix(
 
 namespace mcpp::platform::env {
 
+namespace {
+// Initialised before main, ahead of anything that starts a child.
+const std::string kInheritedPath = [] {
+    const char* p = std::getenv("PATH");
+    return p ? std::string(p) : std::string{};
+}();
+}  // namespace
+
+const std::string& inherited_path() { return kInheritedPath; }
+
 bool offline_mode() {
     // Not cached: `mcpp test` runs nested mcpp invocations in-process in some
     // paths, and a test that flips the var must see the change.

src/build/build_program.cppm

@@ -789,7 +789,7 @@ contract_env(const fs::path& root, const fs::path& outDir, const BuildProgramEnv
         // replaces a variable outright in the child, so writing only the
         // project's own directory would silently be the substitution this
         // deliberately is not.
-        if (const char* inherited = std::getenv("PATH"); inherited && *inherited) {
+        if (auto const& inherited = mcpp::platform::env::inherited_path(); !inherited.empty()) {
             path += mcpp::platform::env::path_list_separator();
             path += inherited;
         }

src/toolchain/msvc.cppm

@@ -1489,8 +1489,10 @@ std::vector<EnvVar> build_env_for_cl(const std::filesystem::path& clPath,
         sdk.root / "Lib" / sdk.version / "ucrt" / a,
         sdk.root / "Lib" / sdk.version / "um" / a,
     })});
+    // The PATH mcpp was started with: the process's own has been given to the
+    // children launched so far, this value among them.
     std::string path = clDir.string();
-    if (const char* p = std::getenv("PATH"); p && *p) {
+    if (auto const& p = mcpp::platform::env::inherited_path(); !p.empty()) {
         path += ';';
         path += p;
     }