feat: Cross-language patch support, real test suites, and a Windows-CI overhaul

[Kybxd]

This PR brings three loosely related but mutually reinforcing changes to the loader:

1. Bring the C# loader to feature parity with Go and C++ (config patching).
2. Convert all three language test harnesses from print-based smoke checks into proper unit-test suites with assertions and exit codes.
3. Make the C++ Windows build path reliable and fast (correct CRT/Debug story, cached protobuf, prepare.bat polish).

---

1. C# config patching (parity with Go / C++)

cmd/protoc-gen-csharp-tableau-loader/embed/{Util,Load}.pc.cs now implement the same patching semantics already shipped in load.go and load.pc.cc:

• scalar fields are overwritten by populated values from the patch;
• repeated (list) fields are appended, or cleared first when PATCH_REPLACE is set;
• map fields are merged by key with recursive PatchMessage on message values, or cleared first when PATCH_REPLACE is set;
• nested message fields are patched recursively.

Implementation uses protobuf reflection (FieldDescriptor.Accessor + IList / IDictionary) and reads sheet- and field-level patch type from the (tableau.worksheet) / (tableau.field).prop extensions.

Load.pc.cs gains:

• LoadMode enum (All / OnlyMain / OnlyPatch);
• PatchDirs, PatchPaths, Mode options on BaseOptions / MessagerOptions;
• LoadMessagerInDir dispatches to a new LoadMessagerWithPatch when a sheet-level patch is declared. PatchPaths takes precedence over PatchDirs, and PatchDirs entries are filtered for existence.

The generated copy under test/csharp-tableau-loader/tableau/ is kept in sync with the embedded source-of-truth.

2. Real unit tests across all three languages

The previous main.cpp / Program.cs used ATOM_DEBUG / Console.WriteLine and a human-readable transcript; failures didn't fail the build. They are replaced with assertion-based suites:

• C++ (GoogleTest): test/cpp-tableau-loader/tests/{hub,patch}_test.cpp and test_paths.h. CMakeLists.txt was restructured to:
  • split sources into a reusable loader_lib (proto-generated + hub/custom code) and a loader test executable;
  • pull in GoogleTest via FetchContent (pinned to v1.14.0, gtest_force_shared_crt = OFF so it follows the project static-CRT setting — see §3);
  • register tests with gtest_discover_tests;
  • drop the legacy src/main.cpp print harness.
• C# (xUnit): tests/{HubTests,BinTests,PatchTests,ActivityConfTests}.cs and a shared HubFixture (Tableau.Registry.Init() is locked + idempotent, and BinTests / PatchTests join the existing [Collection("HubCollection")] so xUnit's parallel test runner can no longer corrupt the non-concurrent registry dictionary).
• Go (testing): main.go is removed, package renamed to gotableauloader_test; main_test.go adds Test_Patch covering the same scenarios as the C++/C# tests (patchconf / patchconf2, multiple patch files, ModeOnlyMain / ModeOnlyPatch) and asserts proto.Equal against testdata/patchresult/RecursivePatchConf.json, confirming Go's xproto.PatchMessage produces the same output as the C++/C# reflection-based implementations.

CI updated accordingly: testing-cpp.yml runs ctest, testing-csharp.yml runs dotnet test, testing-go.yml runs go test ./.... The run_loader matrix entry is gone. Verified on Linux and Windows: ctest 13/13, dotnet test 16/16 (stable across reruns), go test ✓.

3. C++ Windows build correctness & speed

3a. CRT / Debug consistency (the LNK2038 / __acrt_lock AV story)

Three things had to line up to fix the Windows MSVC build:

• Build type — init.bat / init.sh now build the protobuf submodule as Debug (/MTd) for both legacy (v3.x) and modern (v4+/v21+/v32+) variants. The CI step explicitly passes -DCMAKE_BUILD_TYPE=Debug. test/cpp-tableau-loader/CMakeLists.txt deliberately does not inject a default build type, so callers must pass it explicitly; CMAKE_MSVC_RUNTIME_LIBRARY then resolves to MultiThreadedDebug via a $<CONFIG:Debug> generator expression.
• No more stray /DNDEBUG — the old CMAKE_CXX_FLAGS … /W4 /DNDEBUG / … -DNDEBUG lines were removed. Defining NDEBUG while _DEBUG was also active flipped the loader's TUs to _ITERATOR_DEBUG_LEVEL=0 while protobuf and gtest stayed at IDL=2; the linker still accepted the result (everything is /MTd), but std::vector / std::string had incompatible layouts across modules and the process crashed at global-destructor time. The CMakeLists now leaves assert/IDL behaviour to the per-config flags.
• gtest CRT — gtest_force_shared_crt = OFF is forced so googletest follows our static CRT setting. With gtest_force_shared_crt = ON, gtest would link /MD[d] while protobuf and loader_lib link /MT[d]; on Windows that means two coexisting CRT instances inside loader.exe, mismatched heaps, and an Access Violation in gtest_discover_tests at exit.

While diagnosing the above, one more latent bug surfaced and is fixed here:

• Namespace-scope thread_local std::string — the generated util.pc.cc (both the embed/ template and the in-tree generated copy) declared static thread_local std::string g_err_msg at namespace scope. On /MTd this object's TLS dynamic destructor races with __acrt_uninitialize and crashes inside __acrt_lock during exit. Replaced with a Meyers-singleton accessor (ErrMsgRef() returning a function-local static thread_local std::string) so the destructor is sequenced through the standard per-thread atexit mechanism. Same fix applied to both cmd/protoc-gen-cpp-tableau-loader/embed/util.pc.cc and test/cpp-tableau-loader/src/protoconf/util.pc.cc.

Also in util.pc.cc: the legacy (non-abseil) ProtobufLogHandler now passes msg.c_str() to the printf-style ATOM_LOGGER_CALL. Passing a const std::string& to varargs is UB (GCC warns, Clang errors with -Wnon-pod-varargs); the abseil branch already used .c_str().

3b. Faster CI / faster local re-runs

• Cached protobuf — testing-cpp.yml adds an actions/cache@v4 step that caches third_party/_submodules/protobuf/.build/_install, keyed by ${os}-${protobuf-version}-hashFiles(init.sh, init.bat, .gitmodules).
• Idempotent init.{sh,bat} — both scripts compute a build signature (protobuf version + variant + full cmake argument list) and short-circuit when .build/_install/.build_signature matches. When it doesn't, .build is wiped so stale Release/Debug or major-version artefacts can never be silently reused. FORCE_REBUILD_PROTOBUF=1 bypasses the fast path. The fast path also covers the v3.x-on-Windows install layout (.build\_install\cmake\protobuf-config.cmake, no lib\ prefix), which the v4+ path missed.
• No more --recursive submodule init — protobuf's nested submodules (googletest, benchmark on v3.x) are gated behind tests/benchmarks (we keep both off), and modern protobuf uses FetchContent instead of submodules. init.{sh,bat} and actions/checkout switch to --init third_party/_submodules/protobuf / submodules: true.
• No more redundant choco install — windows-latest already preinstalls CMake 3.31, Ninja 1.13 and the full VS2022 / MSVC C++ toolchain, so the Windows install step is dropped (saves 2–5 min per matrix job). ubuntu-latest already has CMake; only ninja-build is apt-get installed.

Net effect on a warm cache: the "Init submodules and build protobuf" step drops from ~10 min to a couple of seconds across all four matrix combinations.

3c. prepare.bat and docs

• prepare.bat gains a Step 4 that downloads buf v1.67.0 (matching the bufbuild/buf-action@v1 pin used in every testing-*.yml) into %LOCALAPPDATA%\buf\bin — no admin rights required for that step. It hooks into the existing --dry-run / --simulate-clean framework. The "equivalent to CI step" comments are refreshed (Ninja/CMake notes, vcvarsall ↔ ilammy/msvc-dev-cmd@v1, buf version sourced from BUF_VERSION instead of being hard-coded).
• README.md is updated in several places:
  • clarify that only the installation half of prepare.bat is one-shot — the MSVC environment is exported via endlocal & set ... and must be re-applied in every new cmd session (not PowerShell);
  • document the new "fast-path / FORCE_REBUILD_PROTOBUF=1" flow;
  • require Debug-on-both-sides on Windows and pass -DCMAKE_BUILD_TYPE=Debug in every cmake invocation;
  • C# section: split buf generate into macOS/Linux, Windows cmd, and PowerShell variants (the old bash-style PATH=... prefix is invalid in PowerShell and silently caused users to skip code generation);
  • bump documented Go to 1.24 to match go.mod.
• CI: read the Go version from go.mod via go-version-file instead of hard-coding 1.24.x in every workflow (testing-*.yml, release-*.yml).

4. Misc

• .gitignore: ignore *.lscache (VS Code C# Dev Kit cache).
• Line endings: normalize the remaining text fixtures (init.sh, several test/testdata/{conf,patchconf,patchconf2}/Patch*Conf.{json,txtpb}) to LF; .gitattributes updated accordingly.

Verification

	Linux	Windows
ctest --test-dir build --output-on-failure	13/13 ✓	13/13 ✓
dotnet test	16/16 ✓ (5× rerun)	16/16 ✓ (5× rerun)
go test ./...	✓	✓

Cold-cache CI run: same as before (~10 min protobuf compile per matrix entry). Warm-cache CI run: protobuf step <30 s.