Refactor ExpressionRunner (#2804)

Tackles the concerns raised in #2797 directly related to #2702 by reverting merging all of `PrecomputeExpressionRunner` into the base `ExpressionRunner`, instead adding a common base for both the precompute pass and the new C-API to inherit. No functional changes.

---

### Current hierarchy after #2702 is

```
ExpressionRunner
├ [PrecomputeExpressionRunner]
├ [CExpressionRunner]
├ ConstantExpressionRunner
└ RuntimeExpressionRunner
```

where `ExpressionRunner` contains functionality not utilized by `ConstantExpressionRunner` and `RuntimeExpressionRunner`.

### New hierarchy will be:

```
ExpressionRunner
├ ConstantExpressionRunner
│  ├ [PrecomputeExpressionRunner]
│  └ [CExpressionRunner]
├ InitializerExpressionRunner
└ RuntimeExpressionRunner
```

with the precompute pass's and the C-API's shared functionality now moved out of `ExpressionRunner` into a new `ConstantExpressionRunner`. Also renames the previous `ConstantExpressionRunner` to `InitializerExpressionRunner` to [better represent its uses](https://webassembly.org/docs/modules/#initializer-expression) and to make its previous name usable for the new intermediate template, where it fits perfectly. Also adds a few comments answering some of the questions that came up recently.

### Old hierarchy before #2702 for comparison:

```
ExpressionRunner
├ [PrecomputeExpressionRunner]
├ ConstantExpressionRunner
└ RuntimeExpressionRunner
```

Author: dcodeIO

src/binaryen-c.cpp

@@ -4998,16 +4998,18 @@ BinaryenExpressionRef RelooperRenderAndDispose(RelooperRef relooper,
 
 namespace wasm {
 
-class CExpressionRunner final : public ExpressionRunner<CExpressionRunner> {
+// Evaluates a suspected constant expression via the C-API. Inherits most of its
+// functionality from ConstantExpressionRunner, which it shares with the
+// precompute pass, but must be `final` so we can `delete` its instances.
+class CExpressionRunner final
+  : public ConstantExpressionRunner<CExpressionRunner> {
 public:
   CExpressionRunner(Module* module,
                     CExpressionRunner::Flags flags,
                     Index maxDepth,
                     Index maxLoopIterations)
-    : ExpressionRunner<CExpressionRunner>(
+    : ConstantExpressionRunner<CExpressionRunner>(
         module, flags, maxDepth, maxLoopIterations) {}
-
-  void trap(const char* why) override { throw NonconstantException(); }
 };
 
 } // namespace wasm

src/passes/Precompute.cpp

@@ -42,9 +42,11 @@ namespace wasm {
 typedef std::unordered_map<LocalGet*, Literals> GetValues;
 
 // Precomputes an expression. Errors if we hit anything that can't be
-// precomputed.
+// precomputed. Inherits most of its functionality from
+// ConstantExpressionRunner, which it shares with the C-API, but adds handling
+// of GetValues computed during the precompute pass.
 class PrecomputingExpressionRunner
-  : public ExpressionRunner<PrecomputingExpressionRunner> {
+  : public ConstantExpressionRunner<PrecomputingExpressionRunner> {
 
   // Concrete values of gets computed during the pass, which the runner does not
   // know about since it only records values of sets it visits.
@@ -66,7 +68,7 @@ class PrecomputingExpressionRunner
   PrecomputingExpressionRunner(Module* module,
                                GetValues& getValues,
                                bool replaceExpression)
-    : ExpressionRunner<PrecomputingExpressionRunner>(
+    : ConstantExpressionRunner<PrecomputingExpressionRunner>(
         module,
         replaceExpression ? FlagValues::PRESERVE_SIDEEFFECTS
                           : FlagValues::DEFAULT,
@@ -82,10 +84,9 @@ class PrecomputingExpressionRunner
         return Flow(values);
       }
     }
-    return ExpressionRunner<PrecomputingExpressionRunner>::visitLocalGet(curr);
+    return ConstantExpressionRunner<
+      PrecomputingExpressionRunner>::visitLocalGet(curr);
   }
-
-  void trap(const char* why) override { throw NonconstantException(); }
 };
 
 struct Precompute