Write shaderCache.bin next to the executable instead of CWD (#1670)

## Problem

`ShaderCache.SaveAndLoad` writes `shaderCache.bin` to the current
working directory:

```cpp
static const char* shaderCacheFileName = "shaderCache.bin";
std::ofstream stream(shaderCacheFileName, std::ios::binary);
```

When `UnitTests.exe` is launched from anywhere that isn't the build
output directory (e.g. the repo root), the file lands in that directory
and is never cleaned up. A unit test should not leave artifacts in the
user's working directory.

## Fix

Write the file next to the executable instead. Added a
`GetExecutableDirectory()` helper declared in `App.h` and implemented
per-platform:

- **Win32** — `GetModuleFileNameW(nullptr, ...)`
- **Apple** — `_NSGetExecutablePath` + `std::filesystem::canonical`
- **X11/Linux** — `std::filesystem::canonical("/proc/self/exe")`

The test now uses `GetExecutableDirectory() / "shaderCache.bin"`,
asserts each stream opened successfully, and asserts on the result of
`std::filesystem::remove` so silent cleanup failures are visible.

No collisions between concurrent runs are possible (each CMake build has
its own `UnitTests.exe`), and artifacts land alongside the build output
rather than in the user's current directory or system temp.

## Testing

Ran `UnitTests.exe --gtest_filter="ShaderCache.*"` from the repo root:
test passes, no `shaderCache.bin` left behind at the repo root or next
to the executable.

[Created by Copilot on behalf of @bghgary]

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: bghgary

Apps/UnitTests/Source/App.Apple.mm

@@ -1,6 +1,20 @@
 #include "App.h"
 #include <Babylon/DebugTrace.h>
 
+#include <mach-o/dyld.h>
+
+std::filesystem::path GetExecutableDirectory()
+{
+    uint32_t size = 0;
+    _NSGetExecutablePath(nullptr, &size);
+    std::string buffer(size, '\0');
+    if (_NSGetExecutablePath(buffer.data(), &size) != 0)
+    {
+        throw std::runtime_error{"_NSGetExecutablePath failed"};
+    }
+    return std::filesystem::canonical(buffer).parent_path();
+}
+
 int main(int argc, char* argv[])
 {
     Babylon::DebugTrace::EnableDebugTrace(true);

Apps/UnitTests/Source/App.Win32.cpp

@@ -7,6 +7,17 @@ LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
     return ::DefWindowProc(hWnd, msg, wParam, lParam);
 }
 
+std::filesystem::path GetExecutableDirectory()
+{
+    wchar_t buffer[MAX_PATH];
+    const DWORD length = GetModuleFileNameW(nullptr, buffer, MAX_PATH);
+    if (length == 0 || length == MAX_PATH)
+    {
+        throw std::runtime_error{"GetModuleFileNameW failed"};
+    }
+    return std::filesystem::path{buffer}.parent_path();
+}
+
 int main(int argc, char* argv[])
 {
     SetConsoleOutputCP(CP_UTF8);

Apps/UnitTests/Source/App.X11.cpp

@@ -16,6 +16,11 @@ namespace
     constexpr const char* wmDeleteWindowName = "WM_DELETE_WINDOW";
 }
 
+std::filesystem::path GetExecutableDirectory()
+{
+    return std::filesystem::canonical("/proc/self/exe").parent_path();
+}
+
 int main(int argc, char* argv[])
 {
     XInitThreads();

Apps/UnitTests/Source/App.h

@@ -2,4 +2,8 @@
 
 #include <Babylon/Graphics/Device.h>
 
-int RunTests(const Babylon::Graphics::Configuration& config, int argc, char* argv[]);
+#include <filesystem>
+
+int RunTests(const Babylon::Graphics::Configuration& config, int argc, char* argv[]);
+
+std::filesystem::path GetExecutableDirectory();

Apps/UnitTests/Source/Tests.ShaderCache.cpp

@@ -8,8 +8,11 @@
 #include <Babylon/Plugins/ShaderCache.h>
 #include <Babylon/ScriptLoader.h>
 
+#include "App.h"
+
 #include <chrono>
 #include <cstdlib>
+#include <filesystem>
 #include <optional>
 #include <future>
 #include <iostream>
@@ -76,18 +79,25 @@ TEST(ShaderCache, SaveAndLoad)
         update.Start();
     }
 
-    static const char* shaderCacheFileName = "shaderCache.bin";
+    const auto shaderCachePath = GetExecutableDirectory() / "shaderCache.bin";
+
     uint32_t shaderCount{};
     {
-        std::ofstream stream(shaderCacheFileName, std::ios::binary);
+        std::ofstream stream(shaderCachePath, std::ios::binary);
+        ASSERT_TRUE(stream.is_open()) << "Failed to open for write: " << shaderCachePath;
         shaderCount = Babylon::Plugins::ShaderCache::Save(stream);
         EXPECT_EQ(shaderCount, 1);
     }
     {
-        std::ifstream stream(shaderCacheFileName, std::ios::binary);
+        std::ifstream stream(shaderCachePath, std::ios::binary);
+        ASSERT_TRUE(stream.is_open()) << "Failed to open for read: " << shaderCachePath;
         auto deserializedCount = Babylon::Plugins::ShaderCache::Load(stream);
         EXPECT_EQ(deserializedCount, shaderCount);
     }
+    std::error_code ec;
+    const auto removed = std::filesystem::remove(shaderCachePath, ec);
+    EXPECT_FALSE(ec) << "Failed to remove " << shaderCachePath << ": " << ec.message();
+    EXPECT_TRUE(removed) << "Expected shader cache file to be removed: " << shaderCachePath;
 
     update.Finish();
     device.FinishRenderingCurrentFrame();