fix(worker): rethrow ordinary failures until a termination materializes

ReThrowToV8 skipped the throw whenever the runtime's termination-requested
flag was set. Between terminate() setting that flag and V8 delivering the
interrupt, JS still runs, so an ordinary native failure in that window
returned nothing: require() yielded undefined and a native constructor
handed back an uninitialized object, which a following call could trip an
assert on in Debug builds. The skip now keys on IsExecutionTerminating()
alone; inside a callback a materialized termination is never cleared on the
way up, so that signal is sufficient there.

Also gives the module-instantiate failure in LoadESModule the same
termination check as the runner's other failure sites, so a terminated link
is reported as an interruption rather than logged as an instantiation error.

Author: edusperoni

NativeScript/runtime/ModuleInternal.mm

@@ -1652,6 +1652,13 @@ throw NativeScriptException(isolate, tcCompile,
 
     if (!linked) {
       RemoveModuleFromRegistry(isolate, canonicalPath);
+      Runtime* runtime = Runtime::GetRuntime(isolate);
+      if (tcLink.HasTerminated() || isolate->IsExecutionTerminating() ||
+          (runtime != nullptr && runtime->IsTerminationRequested())) {
+        logPhase("instantiate", "terminated");
+        throw NativeScriptException("Module evaluation interrupted by isolate termination: " +
+                                    canonicalPath);
+      }
       const char* classification = "unknown";
       if (tcLink.HasCaught()) {
         Local<Message> msg = tcLink.Message();

NativeScript/runtime/NativeScriptException.mm

@@ -714,13 +714,12 @@ static bool GiveWorkerOnErrorAChance(Isolate* isolate, Local<Context> context, L
 }
 
 void NativeScriptException::ReThrowToV8(Isolate* isolate) {
-  // An isolate that is terminating keeps its termination pending until the JS
-  // frames below unwind; throwing on it would replace that with an ordinary
-  // error, and building the error allocates on a heap that may have just hit
-  // its cap. The failure being re-armed here is the termination itself.
-  Runtime* runtime = Runtime::GetRuntime(isolate);
-  if (isolate->IsExecutionTerminating() ||
-      (runtime != nullptr && runtime->IsTerminationRequested())) {
+  // A materialized termination stays pending until the JS frames below
+  // unwind; throwing would replace it with an ordinary error. Only the V8
+  // signal counts here, not the runtime's termination-requested flag: while
+  // the request has not materialized, JS still runs, and an ordinary failure
+  // must still throw or the caller would continue with a bogus result.
+  if (isolate->IsExecutionTerminating()) {
     return;
   }
   @try {