feat(lint): const-local and constexpr-constant rules

Two rules the AST makes possible, plus the mutation analysis behind them.

const-local reports a local that is never written. It is restricted to SCALARS
— integers, bools, enums, floating types — and that restriction is what makes
the answer exact rather than a guess: a scalar has no member functions, so the
only ways to write one are assignment, ++/--, having its address taken, or
binding to a non-const reference. All four are now tracked in the walk:

  - assignment and compound assignment visit their LEFT operand in a write
    context, the right one normally;
  - ++/-- and & write their operand;
  - a call argument is checked against the callee's parameter type, so passing
    to `const int&` or by value is a read while `int&` is a write;
  - initialising a non-const reference writes what it binds to.

For a class type a non-const method call could mutate it, and deciding that is
the whole-program analysis clang-tidy does, so those are simply out of scope
rather than guessed at.

constexpr-constant promotes a const constant whose initialiser is made only of
literals and operators, so `const int A = 1 << 4;` qualifies and
`const int B = Compute();` does not.

On this repository const-local found 103 candidates, which was too many to be
useful, and the reason was informative: most were range-for bindings and
pointer locals. `for (T* const x : …)` and `T* const p` are not spellings
anybody writes, and the useful constness for a pointer is on the pointee, which
this rule cannot advise on. Excluding both leaves 36, all plain bool or enum
locals worth fixing — isWasm, isPe, exists, writes, isC and so on. Those 36 are
fixed in this commit; the compiler verified every one.

Both rules are report-only. The analysis is exact, but adding const is a
judgement about intent as much as mechanics, and a wrong suggestion should cost
a glance rather than a build. const-local also deliberately does not become a
transform: inserting `const` before a shared type would apply it to every
declarator in a multi-declarator statement, including any that IS written.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

interfaces/Crafter.Build-Clang.cppm

@@ -202,6 +202,27 @@ export namespace Crafter {
         // header, so the type-modernising rules must leave its bytes alone.
         // Replaces the hand-maintained substring denylists, which could only
         // ever grow: a new external library needs no new entry here.
+        // ---- constness ----
+        // The declared type is const-qualified.
+        bool isConst = false;
+        // A scalar: integer, floating, bool, enum or pointer. For these,
+        // "is it ever written" is decidable from assignments, ++/--, address-of
+        // and reference bindings alone — there are no member calls that could
+        // mutate it — so isMutated is exact rather than a guess.
+        bool isScalar = false;
+        // Written to somewhere in this file: assigned, incremented, had its
+        // address taken, or bound to a non-const reference. Only meaningful
+        // for a declaration whose uses are all in this file, so a local rather
+        // than something with external linkage.
+        bool isMutated = false;
+        // Method declared const. Only set for Method.
+        bool isConstMethod = false;
+        // Method declared static. Only set for Method.
+        bool isStaticMethod = false;
+        // The binding of a range-for: `for (T x : range)`. A loop binding is
+        // not a variable a reader thinks of as assignable, so constness advice
+        // about it is noise.
+        bool isLoopVariable = false;
         bool isExternC = false;    // declared with C language linkage
         bool isForeignApi = false; // its type or its body binds to an entity
                                    // declared outside the project root