Simplify MODULARIZE code to always use async factory function

The docs here were wrong.  We have the `addRunDependency` system that
can delay module's readiness for an arbitrary amount of time, even if
async compilation is disabled.

This `addRunDependency` system does not exist in MINUMAL_RUTTIME, so in
some cases we can avoid the ready promise in MINIMAL_RUNTIME mode, but
that is a pretty subtle distinction that only applies to MINIMAL_RUNTIME.
Also even in this mode we were still marking the factory function as
async (note the lack of USE_READY_PROMISE in the existing condition).

Author: sbc100

src/modularize.js

@@ -19,7 +19,7 @@ var {{{ EXPORT_NAME }}} = (() => {
   // after document.currentScript is gone, so we save it.
   // In EXPORT_ES6 mode we can just use 'import.meta.url'.
   var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined;
-  return {{{ asyncIf(WASM_ASYNC_COMPILATION || (EXPORT_ES6 && ENVIRONMENT_MAY_BE_NODE)) }}}function(moduleArg = {}) {
+  return async function(moduleArg = {}) {
     var moduleRtn;
 
 "<<< INNER_JS_CODE >>>"
@@ -30,7 +30,7 @@ var {{{ EXPORT_NAME }}} = (() => {
 #else
 // When targetting node and ES6 we use `await import ..` in the generated code
 // so the outer function needs to be marked as async.
-{{{ asyncIf(WASM_ASYNC_COMPILATION || (EXPORT_ES6 && ENVIRONMENT_MAY_BE_NODE)) }}}function {{{ EXPORT_NAME }}}(moduleArg = {}) {
+async function {{{ EXPORT_NAME }}}(moduleArg = {}) {
   var moduleRtn;
 
 "<<< INNER_JS_CODE >>>"

src/settings.js

@@ -1257,14 +1257,9 @@ var DETERMINISTIC = false;
 // By default we emit all code in a straightforward way into the output
 // .js file. That means that if you load that in a script tag in a web
 // page, it will use the global scope. With ``MODULARIZE`` set, we instead emit
-// the code wrapped in a function that returns a promise. The promise is
-// resolved with the module instance when it is safe to run the compiled code,
-// similar to the ``onRuntimeInitialized`` callback. You do not need to use the
-// ``onRuntimeInitialized`` callback when using ``MODULARIZE``.
-//
-// (If WASM_ASYNC_COMPILATION is off, that is, if compilation is
-// *synchronous*, then it would not make sense to return a Promise, and instead
-// the Module object itself is returned, which is ready to be used.)
+// the code wrapped in an async function. This functions returns a promise that
+// resolves to a module instance when once it is safe to run the compiled code
+// (similar to the ``onRuntimeInitialized`` callback).
 //
 // The default name of the function is ``Module``, but can be changed using the
 // ``EXPORT_NAME`` option. We recommend renaming it to a more typical name for a