feat(kernel): R7a C/C++ walker — dual-lang ccpp module, preParse hoist, 7 new blanks, c/cpp default-routed (#1346)

Parity: 0 diffs on redis/git/fmt/protobuf/ALS sweeps; full-init dumps
byte-identical on all five + linux at kernel scale (10.4M dump lines,
same sha256 both arms). Linux 2c/6GB envelope: kernel-arm 19.1min vs
wasm-arm 22.9min (parse 356s vs 435s) on a much richer graph (the new
blanks recover error-swallowed code: git 2x nodes, linux kernel/+mm/ 3x).
Deferral guard corrected by measurement (C/C++ error incidence 9-42%;
--max-deferral flag); defer-reuse memo kills the 3x re-blank/re-parse
cost deferred files paid.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

__tests__/fixtures/kernel-parity/torture.cpp

@@ -0,0 +1,140 @@
+/// Torture fixture for the C++ kernel walker (R7a) — namespaces (incl. C++17
+/// nested + anonymous), out-of-line Cls::method defs, templates + template
+/// bases, operator definitions, stack construction, local fn-ptrs, UE-macro
+/// shapes THROUGH the hoisted preParse, using-aliases, access specifiers,
+/// static-member value reads, and the cpp call shapes. Must parse ERROR-FREE
+/// post-preParse or the kernel arm defers (spaced operator CALL SITES live in
+/// torture-defer.cpp — they produce ERROR nodes by design).
+#include <vector>
+#include "widget_base.hpp"
+
+namespace app {
+
+/** Engine config (docstring). */
+class Config {
+public:
+  int retries;
+  void apply();
+  int helper_count() const { return 2; }
+
+private:
+  int secret;
+};
+
+void Config::apply() { retries = helper_count(); }
+
+namespace detail {
+struct Counter {
+  int value;
+  Counter *next;
+};
+}  // namespace detail
+
+int detail_probe() { return 1; }
+
+}  // namespace app
+
+namespace app::net {
+class Session {
+public:
+  void open();
+  virtual ~Session() {}
+};
+void Session::open() {}
+}  // namespace app::net
+
+namespace {
+int hidden_helper() { return 3; }
+}  // namespace
+
+template <typename T>
+class Base {
+public:
+  T item;
+};
+
+template <typename T>
+class Box : public Base<T> {
+public:
+  T get() const { return value_; }
+  T unwrap();
+
+private:
+  T value_;
+};
+
+template <typename T>
+T Box<T>::unwrap() {
+  return value_;
+}
+
+class Derived : public Base<int>, private app::Config {
+public:
+  Derived() : total_(0) {}
+  int total() const { return total_; }
+
+private:
+  int total_;
+};
+
+struct Vec2 {
+  float x, y;
+  Vec2 operator+(const Vec2 &o) const { return {x + o.x, y + o.y}; }
+  explicit operator bool() const { return x != 0 || y != 0; }
+  Vec2 origin();
+};
+
+enum class Mode : unsigned char { Off, On };
+enum Legacy { LEGACY_A, LEGACY_B };
+typedef struct {
+  int id;
+} packet_t;
+using Handle = app::Config;
+
+// UE-macro shapes — every one below is recovered by the hoisted preParse
+// (export macro, reflection markup, inline specifier, API member prefix).
+class MYMODULE_API Widget : public app::Config {
+public:
+  UPROPERTY(EditAnywhere, Category = "State")
+  float Health;
+  FORCEINLINE float GetHealth() const { return Health; }
+  ENGINE_API virtual void Tick(float Delta);
+};
+
+void Widget::Tick(float Delta) { Health += Delta; }
+
+Config GlobalConfig;
+int build_number = 7;
+
+template <typename T>
+T compute_seed(T v) {
+  return v + 1;
+}
+
+float drive_helper(float v) { return v; }
+
+Widget *make_widget() { return new Widget(); }
+
+float drive() {
+  Widget local;
+  app::Config cfg;
+  Vec2 a{1, 2};
+  Vec2 b(a);
+  Vec2 c2(1.5f, 2.5f);
+  float f = a.x + b.y + c2.x;
+  make_widget()->Tick(0.5f);
+  auto kernel = &compute_seed<float>;
+  if (f > 1) {
+    kernel = &drive_helper;
+  }
+  float r = kernel(f);
+  int flags = GlobalConfig.retries;
+  Mode m = Mode::Off;
+  int leg = LEGACY_A;
+  app::detail_probe();
+  compute_seed<int>(2);
+  auto mp = &app::Config::apply;
+  (void)mp;
+  (void)m;
+  return r + f + flags + leg;
+}