Tests.ExternalTexture.Msaa: migrate to synchronous CreateForJavaScript

With BabylonJS#1646's synchronous ExternalTexture::CreateForJavaScript and BabylonJS#1652's
new threading model both in this branch, the original test pattern is
both unnecessary and broken:

- Unnecessary: AddToContextAsync's two-frame dance (queue in frame 1,
  wait for bgfx::frame() to resolve the promise, run startup in frame 2)
  exists only because the texture wrap was async. CreateForJavaScript is
  synchronous so the wrap, startup(), and renderFrame() all run in the
  same JS task inside a single frame.
- Broken: under the new model, SubmitCommands synchronously acquires a
  FrameCompletionScope which blocks when no frame is in progress.
  The old between-frames startup() pattern deadlocks.

Collapse to a single frame + single dispatch that wraps the texture,
runs startup(), and chains renderFrame()'s promise resolution. The host
app pattern host apps should follow with the new API.

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

Author: bghgary

Apps/UnitTests/Source/Tests.ExternalTexture.Msaa.cpp

@@ -36,8 +36,6 @@ namespace
             device.GetPlatformInfo().Device, TEX_SIZE, TEX_SIZE, 1, true, samples);
         Babylon::Plugins::ExternalTexture externalTexture{nativeTexture};
 
-        std::promise<void> startupDone;
-
         Babylon::AppRuntime::Options options{};
         options.UnhandledExceptionHandler = [](const Napi::Error& error) {
             std::cerr << "[Uncaught Error] " << Napi::GetErrorString(error) << std::endl;
@@ -60,43 +58,19 @@ namespace
         loader.LoadScript("app:///Assets/babylon.max.js");
         loader.LoadScript("app:///Assets/tests.externalTexture.msaa.js");
 
-        // Queue AddToContextAsync inside the current bgfx frame and wire its .then to startup().
-        std::promise<void> addToContextCalled;
-        loader.Dispatch([&externalTexture, &addToContextCalled, &startupDone, samples](Napi::Env env) {
-            auto jsPromise = externalTexture.AddToContextAsync(env);
-            addToContextCalled.set_value();
-
-            auto jsOnFulfilled = Napi::Function::New(env, [&startupDone, samples](const Napi::CallbackInfo& info) {
-                auto jsNativeTexture = info[0];
-                info.Env().Global().Get("startup").As<Napi::Function>().Call({
-                    jsNativeTexture,
-                    Napi::Number::New(info.Env(), TEX_SIZE),
-                    Napi::Number::New(info.Env(), TEX_SIZE),
-                    Napi::Number::New(info.Env(), samples),
-                });
-                startupDone.set_value();
-            });
-
-            auto jsOnRejected = Napi::Function::New(env, [&startupDone](const Napi::CallbackInfo& info) {
-                startupDone.set_exception(std::make_exception_ptr(
-                    std::runtime_error{Napi::GetErrorString(info[0].As<Napi::Error>())}));
+        // CreateForJavaScript is synchronous so startup() can run in the same JS task as the
+        // texture wrap. renderFrame() submits draw commands which are flushed when the frame ends.
+        std::promise<void> renderDone;
+        loader.Dispatch([&externalTexture, &renderDone, samples](Napi::Env env) {
+            auto jsNativeTexture = externalTexture.CreateForJavaScript(env);
+
+            env.Global().Get("startup").As<Napi::Function>().Call({
+                jsNativeTexture,
+                Napi::Number::New(env, TEX_SIZE),
+                Napi::Number::New(env, TEX_SIZE),
+                Napi::Number::New(env, samples),
             });
 
-            jsPromise.Get("then").As<Napi::Function>().Call(jsPromise, {jsOnFulfilled, jsOnRejected});
-        });
-
-        // Ensure AddToContextAsync was queued in the current frame, then finish it so the promise resolves.
-        addToContextCalled.get_future().wait();
-        update.Finish();
-        device.FinishRenderingCurrentFrame();
-        startupDone.get_future().get();
-
-        // New frame: drive a single renderFrame() on the JS side.
-        device.StartRenderingCurrentFrame();
-        update.Start();
-
-        std::promise<void> renderDone;
-        loader.Dispatch([&renderDone](Napi::Env env) {
             auto jsPromise = env.Global().Get("renderFrame").As<Napi::Function>().Call({}).As<Napi::Promise>();
 
             auto jsOnFulfilled = Napi::Function::New(env, [&renderDone](const Napi::CallbackInfo&) {