feat(incremental): rebuild when an #included header changes

The staleness check compared an artifact against its own source and its
module imports. Headers were in neither set: the scanner reads `import`
lines, and a .cppm or .cpp keeps its mtime when a header it includes is
edited — so the build reported nothing to do and left objects compiled
against the previous contents. Same silent mixed-layout binary as issue
27, reached through #include instead of import.

Ask the compiler what it actually opened. Every C++ and C compile now
passes -MD -MF <artifact>.d, and Check reads that depfile back through
NewestPrerequisite, comparing every prerequisite's mtime against the
artifact. A missing depfile (an object from a crafter-build that wrote
none) or a prerequisite that no longer exists reads as "rebuild": neither
is evidence of freshness.

The parser unescapes make syntax rather than splitting on whitespace,
since clang wraps depfiles onto continuation lines and escapes spaces in
filenames.

implementations/Crafter.Build-Platform.cpp

@@ -164,6 +164,71 @@ fs::path Crafter::GetCrafterBuildHome() {
     throw std::runtime_error(msg);
 }
 
+fs::file_time_type Crafter::NewestPrerequisite(const fs::path& depFile) {
+    std::ifstream in(depFile, std::ios::binary);
+    if (!in) return fs::file_time_type::max();
+    std::ostringstream buffer;
+    buffer << in.rdbuf();
+    const std::string text = std::move(buffer).str();
+
+    // Make-rule tokenizing, as clang writes it: `target: prereq prereq`, with a
+    // trailing '\' continuing the rule onto the next line (clang wraps at ~80
+    // columns, so any real depfile has several), '\ ' and '\#' escaping a
+    // character into a filename, and '$$' standing for a literal '$'. A
+    // backslash that is none of those is a Windows path separator and stays.
+    std::vector<std::string> tokens;
+    std::string token;
+    auto flush = [&tokens, &token]() {
+        if (!token.empty()) {
+            tokens.push_back(token);
+            token.clear();
+        }
+    };
+    for (std::size_t i = 0; i < text.size(); ++i) {
+        const char c = text[i];
+        const char next = i + 1 < text.size() ? text[i + 1] : '\0';
+        if (c == '\\' && (next == '\n' || next == '\r')) {
+            flush();
+            ++i;
+        } else if (c == '\\' && (next == ' ' || next == '\t' || next == '#')) {
+            token += next;
+            ++i;
+        } else if (c == '$' && next == '$') {
+            token += '$';
+            ++i;
+        } else if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+            flush();
+        } else {
+            token += c;
+        }
+    }
+    flush();
+
+    // A token ending in ':' names a rule target, not an input. The first one
+    // closes the target list (and a Windows `C:\build\x.o:` still ends in ':',
+    // where splitting on the first colon would not); a later one opens another
+    // rule, as `-MP` phony targets do, whose name is not a file to stat.
+    bool sawTarget = false;
+    fs::file_time_type newest = fs::file_time_type::min();
+    for (const std::string& prerequisite : tokens) {
+        if (prerequisite.ends_with(':')) {
+            sawTarget = true;
+            continue;
+        }
+        if (!sawTarget) continue;
+        std::error_code ec;
+        const fs::file_time_type stamp = fs::last_write_time(prerequisite, ec);
+        // A prerequisite that has since been deleted makes the recorded set
+        // unusable as evidence — the source that included it must have changed
+        // too, and rebuilding is what writes a depfile that no longer names it.
+        if (ec) return fs::file_time_type::max();
+        if (stamp > newest) newest = stamp;
+    }
+    // No rule at all: a truncated or empty depfile proves nothing.
+    if (!sawTarget) return fs::file_time_type::max();
+    return newest;
+}
+
 bool Crafter::MatchGlob(std::string_view glob, std::string_view name) {
     std::size_t gi = 0;
     std::size_t ni = 0;