test: two builds of one module are refused before anything compiles

The fixture is P -> M and P -> A -> M, where M's own flag --wide
changes a struct it exports. Loaded with --wide --split, P gives M its
args without --wide while A passes them on whole: Build(P) has to fail,
name the module and both paths, and leave no bin/ anywhere. Loaded with
--wide alone, both paths give M the same list, there is one M, and the
build has to go through. Before the fix the first case built cleanly.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/DuplicateModule/main.cpp

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
+
+import std;
+import Crafter.Build;
+namespace fs = std::filesystem;
+using namespace Crafter;
+
+// A program can hold one module of each name, so Build() refuses a graph in
+// which two configurations export the same module: the same project loaded
+// along two paths with two arg lists, say. It used to build both and put
+// both on the consumer's module path. Clang took the first for every import
+// of the module, the ones inside the other build's consumers included, and
+// the program linked code compiled against two layouts of one struct: it
+// built cleanly, then read garbage or crashed (issue #41). The fixture is
+// P -> M and P -> A -> M. With --split, P gives M its args without --wide,
+// which changes what M declares, while A passes them on whole.
+namespace {
+    std::int32_t Failures = 0;
+
+    void Check(bool cond, std::string_view msg) {
+        if (!cond) {
+            std::println(std::cerr, "FAIL: {}", msg);
+            ++Failures;
+        }
+    }
+
+    BuildResult BuildPass(Configuration& cfg) {
+        std::unordered_map<fs::path, std::shared_future<BuildResult>> depResults;
+        std::mutex depMutex;
+        return Build(cfg, depResults, depMutex);
+    }
+}
+
+int main() {
+    const fs::path installedHome = GetCrafterBuildHome();
+    if (!fs::exists(installedHome / "Crafter.Build.cppm")) {
+        std::println(std::cerr, "SKIP: no module sources at {}", installedHome.string());
+        return 77;
+    }
+
+    // Staged because LoadProject and Build drop build/ and bin/ trees next
+    // to the project files.
+    const fs::path fixture = fs::current_path() / "tests" / "DuplicateModule" / "fixture";
+    const fs::path scratch = fs::temp_directory_path() / "crafter-build-duplicate-module";
+    std::error_code ec;
+    fs::remove_all(scratch, ec);
+    fs::create_directories(scratch);
+    fs::copy(fixture, scratch, fs::copy_options::recursive);
+
+    // From P's own directory, as crafter-build runs it: the fixture's
+    // LocalProject paths are relative to the working directory.
+    const fs::path cwd = fs::current_path();
+    fs::current_path(scratch / "p");
+    try {
+        // Two lists for M: refused before anything is built.
+        {
+            std::array<std::string_view, 2> args = { "--wide", "--split" };
+            Configuration cfg = LoadProject("project.cpp", args);
+            const BuildResult built = BuildPass(cfg);
+            Check(!built.result.empty(), "a graph with two builds of one module fails to build");
+            Check(built.result.contains("module M is built twice for P"), std::format("the error names the module and the program (got: {})", built.result));
+            Check(built.result.contains("P -> M (") && built.result.contains("P -> A -> M ("), std::format("the error names the path to each build (got: {})", built.result));
+            Check(!fs::exists(scratch / "m" / "bin") && !fs::exists(scratch / "a" / "bin") && !fs::exists(scratch / "p" / "bin"), "nothing was built");
+        }
+
+        // One list along both paths: one M, and the build goes through.
+        {
+            std::array<std::string_view, 1> args = { "--wide" };
+            Configuration cfg = LoadProject("project.cpp", args);
+            const bool oneM = cfg.dependencies.size() == 2 && cfg.dependencies[1]->dependencies.size() == 1 && cfg.dependencies[0] == cfg.dependencies[1]->dependencies[0];
+            Check(oneM, "the same list along both paths loads one M");
+            const BuildResult built = BuildPass(cfg);
+            Check(built.result.empty(), std::format("the graph with one M builds (got: {})", built.result));
+        }
+    } catch (const std::exception& e) {
+        fs::current_path(cwd);
+        std::println(std::cerr, "FAIL: threw: {}", e.what());
+        return 1;
+    }
+    fs::current_path(cwd);
+
+    return Failures > 0 ? 1 : 0;
+}