Add jetc: a prototype JET-to-C++ compiler, plus the Tag API it needed

jetc (JetCore/jetc/) compiles a subset of JET template syntax - literal
text, $[...]/#[...] variable output, <set>, <if>/<else>, <for>, <while> -
into a standalone C++ program that links against CoreUtils and the same
JetCore tag-class library jet-2.0 itself uses. The static tag/text
structure becomes real C++ control flow (if/for/while), resolved once at
build time instead of being re-scanned character-by-character from raw
source on every request and, for loop bodies, on every single iteration
(confirmed by reading Tag::parseContainer - it re-tokenizes its container
text from scratch every time it runs, since a tag's parse and its
execution are the same pass in this codebase). Anything genuinely
dynamic - variable values, expr/value comparisons, loop bounds - still
calls into the existing runtime (Tag::getVariable/resolveKeyword,
jet::Operand) exactly as the interpreter does; compiling doesn't try to
eliminate that; only the repeated re-parsing of the template's own shape.

A <if type="..."> or <while type="..."> comparison type is resolved to
its C++ operator once at compile time (type is a literal attribute value
in practice, not runtime data) instead of being re-checked against six
string constants on every evaluation.

Any tag jetc doesn't have a codegen rule for (mysql, sql, call, include,
a <set> with a container body, etc.) is captured as its exact raw source
span and handed to the existing interpreter at compiled-program runtime
via the new Tag::interpretSpan(), so an unsupported construct degrades
gracefully instead of failing to compile - a real, if narrower, program
rather than requiring full tag coverage up front.

Tag.h/.cpp: made assignVariable public (parallel to the already-public
getVariable - generated code needs a write path without being a Tag
subclass) and added interpretSpan() as the fallback's entry point into
parseContainer.

Verified live: two representative templates (jetc/demo.jet, an if/for/set
walkthrough; jetc/demo2.jet, a nested <if> inside a <for>, a <while> that
mutates and rereads its own condition variable across iterations, and a
fallback-interpreted <comment> tag) both compile, link, run standalone,
and produce byte-identical output to jet-2.0 running the same source.
Building and running jetc/demo2.jet's <while> loop surfaced a real,
previously-unknown MString bug (fixed separately, see CoreUtils commit
6e4e463) along with a separate, already-existing bug in __while.cpp's
value1/value2/type form (unrelated to this compiler, not fixed here -
see project memory).

jetc/build-compiled.sh builds the compiler and a given .jet file's
compiled binary in one step; jetc/demo.jet and demo2.jet are kept as
worked examples. Known limitations: <set> with a container body isn't
modeled (falls back to interpretation); a fallback-interpreted tag
nested inside compiled control flow uses the template's single top-level
scope for parent/local context rather than a faithful per-level chain,
which only matters for legacy tags that rely on nested "local" scoping.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

jetc/JetCodegen.h

@@ -0,0 +1,35 @@
+#ifndef __JetCodegen_h__
+#define __JetCodegen_h__
+
+#include "JetAST.h"
+#include <string>
+#include <sstream>
+
+namespace jetc {
+
+   // Emits a standalone .cpp translation unit that renders a compiled JET
+   // template. The static tag/text structure becomes real C++ control flow;
+   // anything genuinely dynamic (variable values, expr/value comparisons,
+   // loop bounds) still calls into the existing JetCore/CoreUtils runtime
+   // (Tag::getVariable/resolveKeyword/assignVariable, jet::Operand) exactly
+   // as the interpreter does - compiling doesn't try to eliminate that, only
+   // the repeated re-parsing of the template's own structure.
+   class Codegen {
+    public:
+      std::string generate(const std::vector<NodePtr> &top, const std::string &sourceFileComment);
+
+    private:
+      std::ostringstream out;
+      size_t nextId = 0;
+      std::string id(const std::string &prefix) { return prefix + std::to_string(nextId++) + "_"; }
+
+      void emitBody(const std::vector<NodePtr> &nodes, int indent);
+      void emitNode(const NodePtr &n, int indent);
+      static std::string ind(int indent);
+      static std::string cstr(const std::string &raw);   // C++ string-literal escape
+      static const char *staticTypeOp(const std::string &type, const char *rcVar);
+   };
+
+}
+
+#endif