Metal backend: compiled .mlmodelc bundles leak into shared temp dir and are never reclaimed #1266

Summary

createCoreMLComputeHandle in cpp/neuralnet/metalbackend.swift calls
MLModel.compileModel(at:) to compile the converted .mlpackage, loads the
result, and then discards compiledURL. The compiled .mlmodelc bundle
(~50 MiB for typical nets) is never moved, saved, or deleted — it leaks
permanently on disk on every engine startup that uses the CoreML/ANE path.

Details

The conversion chain writes to two different temp locations:

• CoreMLConversion::generateTempPath places the .mlpackage under
  std::filesystem::temp_directory_path()/katago_coreml/, which honors the
  TMPDIR env var. The Swift side defers deletion of this source package.
• MLModel.compileModel(at:) writes its output into the process's
  NSTemporaryDirectory(). On macOS this resolves via confstr to the
  sandboxed container's shared Data/tmp (or /var/folders/.../T/ for
  unsandboxed runs) and does not honor a TMPDIR override set by the
  parent process.

Per Apple's documentation, compileModel(at:) returns a URL "in a temporary
location" that the caller owns — KataGo currently drops this ownership on the
floor.

Reproduction

Verified on v1.17.2 (6a1fc5de), same code on master.

Run katago analysis with a Mux topology that assigns ANE threads, e.g.
metalDeviceToUseThreadN=100 for two threads, then quit the process:

• Each ANE handle produces one model_<pid>_<threadIdx>_<ts>.mlmodelc
  bundle in NSTemporaryDirectory().
• The bundles persist after process exit (verified with ps — no katago
  processes remain).
• Measured: 2 bundles ≈ 101 MiB per engine launch; 3 sequential
  launch/quit cycles left 6 bundles ≈ 305 MiB.

Hosts that give each engine launch an exclusive TMPDIR and reclaim it on
process exit cannot reach these files, so cleanup only happens if someone
sweeps the shared temp dir by name. GPU-only (MPSGraph) threads are unaffected.

Suggested fix

Keep the compiled bundle inside KataGo-owned lifetime:

1. After compileModel returns, move compiledURL next to the source
   .mlpackage (or into another KataGo-managed temp dir), then load the model
   from the moved URL.
2. Retain the bundle for the CoreMLComputeHandle's lifetime — MLModel may
   touch its files lazily, so deleting right after load is unsafe.
3. Delete the bundle when the handle is torn down (e.g. store the URL on the
   handle and remove it in a teardown/deinit path, after the MLModel is
   released). This keeps ownership fully inside KataGo and does not rely on
   any host-side temp-dir reclaim.

Moving alone (step 1 without 3) already contains the leak for hosts that
reclaim per-process TMPDIR, but step 3 makes the fix self-contained for
standalone use as well.

I have a tested patch implementing steps 1–2 (verified: zero .mlmodelc
residue in shared tmp after engine exit, ~30 lines) and can open a PR —
happy to extend it with handle-teardown cleanup if that is preferred.