fix(scanner): the identity refusal quotes what was read, not what was recorded

The tokeniser stops at the first character it does not accept, so a declaration
it cannot read at all yields an EMPTY name -- and `'' is not a module name`
names nothing the author can find. Measured on a non-ASCII name, where
`is_module_name_char` tests bytes with std::isalnum and every byte of a UTF-8
sequence is false: the message read `''` where the source said `模块`.

GCC 16.1 refuses that declaration too (`unrecognized 'MODULE-EXPORT ...'`), so
this is a clearer sentence for a refusal that already existed rather than a new
restriction. The message now also states what a name is.

Author: speak-agent

src/modgraph/scanner.cppm

@@ -827,11 +827,24 @@ std::expected<SourceUnit, ScanError> scan_file(const std::filesystem::path& file
             // no source could have declared: a recorded non-name propagates
             // into the build graph as a BMI path and is reported by nothing.
             if (!is_well_formed_module_name(name)) {
+                // QUOTE WHAT WAS READ, NOT WHAT WAS RECORDED. The tokeniser
+                // stops at the first character it does not accept, so a
+                // declaration it cannot read at all yields an EMPTY name — and
+                // `'' is not a module name` names nothing the author can find.
+                // The measured case is a non-ASCII name: `is_module_name_char`
+                // tests bytes with std::isalnum, which is false for every byte
+                // of a UTF-8 sequence, so `export module <non-ascii>;` produced
+                // the empty string. (GCC 16.1 refuses that declaration too,
+                // with `unrecognized 'MODULE-EXPORT ...'`, so this is a clearer
+                // sentence for the same refusal rather than a new restriction.)
+                const auto decl = trim(r.substr(0, r.find(';')));
                 return std::unexpected(ScanError{file, lineno,
                     std::format("'{}' is not a module name. A module "
                                 "declaration is `module <name>;`, "
                                 "`module <name>:<partition>;` or "
-                                "`module : private;`.", name)});
+                                "`module : private;`, and a name is a "
+                                "dot-separated sequence of ASCII identifiers.",
+                                name.empty() ? std::string(decl) : name)});
             }
             if (is_export) {
                 if (u.provides) {

tests/unit/test_modgraph.cpp

@@ -1102,6 +1102,30 @@ TEST(Scanner, AModuleIdentityThatIsNotANameIsRefused) {
         << u.error().message;
 }
 
+// The message quotes WHAT WAS READ, not what was recorded.
+//
+// The tokeniser stops at the first character it does not accept, so a
+// declaration it cannot read at all yields an EMPTY name, and `'' is not a
+// module name` names nothing the author can find. A non-ASCII name is the
+// measured case: `is_module_name_char` tests bytes with std::isalnum, false for
+// every byte of a UTF-8 sequence. GCC 16.1 refuses the same declaration with
+// `unrecognized 'MODULE-EXPORT ...'`, so this is a clearer sentence for a
+// refusal that already existed, not a new restriction.
+TEST(Scanner, AnUnreadableModuleNameIsQuotedAsWritten) {
+    auto dir = make_tempdir("mcpp-nonascii");
+    write(dir / "src" / "u.cppm", "export module \u6a21\u5757;\n");
+
+    auto u = scan_file(dir / "src" / "u.cppm", "pkg",
+                       mcpp::builtin_extension_table());
+    ASSERT_FALSE(u.has_value());
+    EXPECT_NE(u.error().message.find("is not a module name"), std::string::npos)
+        << u.error().message;
+    EXPECT_EQ(u.error().message.find("'' is not"), std::string::npos)
+        << "the message quoted an empty name: " << u.error().message;
+    EXPECT_NE(u.error().message.find("\u6a21\u5757"), std::string::npos)
+        << u.error().message;
+}
+
 // The guard above must not refuse what the language allows. A partition, a
 // dotted name and a dotted partition are all names.
 TEST(Scanner, WellFormedNamesSurviveTheIdentityGuard) {