Fail loudly on unknown MLX block kinds; fix MLX build docs

M4 - silent fallthroughs in mlxbackend.cpp, now loud (ASSERT_UNREACHABLE,
the file's existing idiom):
- BlockVariant::apply switch default returned the input unchanged, a silent
  identity no-op block. Now asserts; kept as a default: label so the active
  -Wswitch-default (CMakeLists.txt) stays clean.
- The trunk block-construction loop silently dropped unknown kinds. Added an
  else { ASSERT_UNREACHABLE; }.
- The nested-bottleneck construction loop was a genuine latent bug, not just a
  missing guard: parseResidualBlockStack (desc.cpp, shared by trunk and nested)
  accepts nested_bottleneck_block inside a nested bottleneck and the desc layer
  handles it, but the MLX nested loop omitted NESTED_BOTTLENECK_BLOCK_KIND and
  silently dropped such a block. Added the missing case (mirroring the trunk
  loop and Eigen's shared BlockStack) plus an else-assert.

M3 - Compiling.md implied the MLX backend builds with make, but CMakeLists.txt
hard-fails MLX without the Ninja generator (same Swift/C++ interop requirement
as Metal). Added -G Ninja to the MLX cmake example, listed MLX alongside Metal
for the Ninja prerequisite, and noted MLX uses ninja to build.

Verification: build clean; runtests + runnnlayertests pass; testgpuerror
g170-b6c96 vs eigen_reference.json fp32 near-exact (winrate max 0.00036%) /
fp16 max 0.55% (unchanged); testgpuerror on the b4c256h4nbttflrs nested-
bottleneck+transformer model loads through the modified nested loop and runs
forward with no assert (fp16 ~0.27%).

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

Author: ChinChangYang

Compiling.md

@@ -131,7 +131,7 @@ As also mentioned in the instructions below but repeated here for visibility, if
       * [Homebrew](https://brew.sh): `/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`
       * CMake with a minimum version of 3.18.2: `brew install cmake`.
       * AppleClang and Swift compilers: `xcode-select --install`.
-      * If using the Metal backend, [Ninja](https://ninja-build.org): `brew install ninja`
+      * If using the Metal or MLX backend, [Ninja](https://ninja-build.org): `brew install ninja`
       * If using the Metal backend, protobuf and abseil: `brew install protobuf abseil`
       * If using the MLX backend (Apple Silicon only): `brew install mlx` (≥0.18). Requires CMake ≥3.27. KataGo finds MLX via CMake's default search (Homebrew installs it at `/opt/homebrew/share/cmake/MLX/`); override with `-DMLX_ROOT=/path/to/mlx/cmake` if needed.
       * libzip: `brew install libzip`.
@@ -141,14 +141,14 @@ As also mentioned in the instructions below but repeated here for visibility, if
       * `git clone https://github.com/lightvector/KataGo.git`
    * Compile using CMake and make in the cpp directory:
       * `cd KataGo/cpp`
-      * `cmake . -G Ninja -DUSE_BACKEND=METAL` or `cmake . -DUSE_BACKEND=MLX` or `cmake . -DUSE_BACKEND=OPENCL` or `cmake . -DUSE_BACKEND=EIGEN` depending on which backend you want.
+      * `cmake . -G Ninja -DUSE_BACKEND=METAL` or `cmake . -G Ninja -DUSE_BACKEND=MLX` or `cmake . -DUSE_BACKEND=OPENCL` or `cmake . -DUSE_BACKEND=EIGEN` depending on which backend you want. The METAL and MLX backends use Swift/C++ interop, which requires the Ninja generator (`-G Ninja`); the other backends use the default Make generator.
          * Specify also `-DUSE_TCMALLOC=1` if using TCMalloc.
          * Compiling will also call git commands to embed the git hash into the compiled executable, specify also `-DNO_GIT_REVISION=1` to disable it if this is causing issues for you.
          * Specify `-DUSE_AVX2=1` to also compile Eigen with AVX2 and FMA support, which will make it incompatible with old CPUs but much faster. Intel-based Macs with new processors support AVX2, but Apple Silicon Macs do not support AVX2 natively. (If you want to go further, you can also add `-DCMAKE_CXX_FLAGS='-march=native'` which will specialize to precisely your machine's CPU, but the exe might not run on other machines at all).
          * Specify `-DBUILD_DISTRIBUTED=1` to compile with support for contributing data to public distributed training runs.
             * If building distributed, you will also need to build with Git revision support, including building within a clone of the repo, as opposed to merely an unzipped copy of its source.
             * Only builds from specific tagged versions or branches can contribute, in particular, instead of the `master` branch, use either the latest [release](https://github.com/lightvector/KataGo/releases) tag or the tip of the `stable` branch. To minimize the chance of any data incompatibilities or bugs, please do NOT attempt to contribute with custom changes or circumvent these limitations.
-      * `ninja` for Metal backend, or `make` for other backends.
+      * `ninja` for the Metal and MLX backends, or `make` for other backends.
    * Done! You should now have a compiled `katago` executable in your working directory.
    * Pre-trained neural nets are available at [the main training website](https://katagotraining.org/).
    * You will probably want to edit `configs/gtp_example.cfg` (see "Tuning for Performance" above).

cpp/neuralnet/mlxbackend.cpp

@@ -1167,6 +1167,11 @@ struct NestedBottleneckResidualBlock {
       postBN(desc.postBN, desc.postActivation.activation, useFP16),
       postConv(desc.postConv, inCfg, outCfg, useFP16)
   {
+    // Mirror parseResidualBlockStack (desc.cpp), which accepts the same five
+    // block kinds inside a nested bottleneck as in the trunk - including a
+    // nested bottleneck within a nested bottleneck. Keep this in sync with the
+    // trunk's block loop below; an unhandled kind is a loud bug, not a silent
+    // no-op block.
     for(size_t i = 0; i < desc.blocks.size(); i++) {
       int blockKind = desc.blocks[i].first;
       if(blockKind == ORDINARY_BLOCK_KIND) {
@@ -1175,12 +1180,18 @@ struct NestedBottleneckResidualBlock {
       else if(blockKind == GLOBAL_POOLING_BLOCK_KIND) {
         blocks.emplace_back(*static_cast<GlobalPoolingResidualBlockDesc*>(desc.blocks[i].second.get()), inCfg, outCfg, useFP16);
       }
+      else if(blockKind == NESTED_BOTTLENECK_BLOCK_KIND) {
+        blocks.emplace_back(*static_cast<NestedBottleneckResidualBlockDesc*>(desc.blocks[i].second.get()), inCfg, outCfg, nnX, nnY, useFP16);
+      }
       else if(blockKind == TRANSFORMER_ATTENTION_BLOCK_KIND) {
         blocks.emplace_back(*static_cast<TransformerAttentionDesc*>(desc.blocks[i].second.get()), nnX, nnY, useFP16);
       }
       else if(blockKind == TRANSFORMER_FFN_BLOCK_KIND) {
         blocks.emplace_back(*static_cast<TransformerFFNDesc*>(desc.blocks[i].second.get()), nnX, nnY, useFP16);
       }
+      else {
+        ASSERT_UNREACHABLE;
+      }
     }
   }
 
@@ -1221,7 +1232,11 @@ mx::array BlockVariant::apply(const mx::array& input, const mx::array& mask, con
     case TRANSFORMER_FFN:
       return ffn->apply(input, mask, useMask);
     default:
-      return input;
+      // All BlockVariant::Type values are handled above. Reaching the default
+      // means the tagged union holds an unrecognized type - fail loudly rather
+      // than silently returning the input (an identity no-op block). The
+      // default also satisfies -Wswitch-default (see cpp/CMakeLists.txt).
+      ASSERT_UNREACHABLE;
   }
 }
 
@@ -1327,6 +1342,12 @@ struct Trunk {
       else if(blockKind == TRANSFORMER_FFN_BLOCK_KIND) {
         blocks.emplace_back(*static_cast<TransformerFFNDesc*>(desc.blocks[i].second.get()), nnX, nnY, useFP16);
       }
+      else {
+        // parseResidualBlockStack (desc.cpp) rejects any other kind at load,
+        // so reaching here means a new block kind was added without backend
+        // support - fail loudly instead of silently dropping the block.
+        ASSERT_UNREACHABLE;
+      }
     }
   }