Sequence AST-creating arguments in rewriters for cross-compiler determinism (#10165)

### Problem

The order of evaluation of function arguments is unspecified in C++
(arguments are indeterminately sequenced since C++17). Compilers use
this freedom differently:

```c++
static int f(int i) { printf("%d ", i); return i; }
static void g(int, int, int) { printf("\n"); }
int main() { g(f(1), f(2), f(3)); }
```
| compiler/target | output |
|---|---|
| gcc 13, x86_64 | `3 2 1` |
| gcc 13, aarch64 | `1 2 3` |
| clang 18, x86_64 | `1 2 3` |

Z3 has many call sites where **two or more arguments each create AST
nodes**, e.g. (before this PR, `bv_rewriter.cpp:876`):

```c++
result = m.mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e));
```

The two extract nodes are hash-consed and receive their AST ids in
evaluation order, so the id assignment differs between
compilers/targets. AST ids feed heuristic tie-breaking throughout the
solver (`bool_rewriter`'s `m_order_eq` equality-operand ordering,
id-based sorts in `array_rewriter`, case-split ordering, ...), so
**byte-identical input takes different solver paths depending on the
compiler and architecture z3 was built with**.

### Evidence

Investigated while chasing cross-platform proof-time instability in
CBMC/mldsa-native CI (diffblue/cbmc#8991), on byte-identical ~12 MB SMT2
instances (bit-vectors + arrays + quantifiers), with the `string_hash`
fix from #10163 applied to isolate this effect. Z3 4.15.3, gcc 13 on
x86_64 Linux and aarch64 Linux (Graviton):

* one instance: **17 s on x86_64 vs 1633 s on aarch64** (both `unsat`; a
sibling instance shows the reverse direction). Run-to-run within one
host: ±1 %.
* Instrumenting `ast_manager::register_node_core` with an order
fingerprint (running hash over `(node hash, node id)`) shows both
architectures construct **identical AST sequences up to registration
#41,789**, where x86_64 creates `(extract[0:0] #xFFFFFFFF)` before
`(extract[0:0] #xFFFFFFFE)` and aarch64 the other way around — from
identical call stacks at the `mk_ite`-over-two-`mk_extract` site quoted
above. All divergence between the two hosts flows from such events
(pointer/ASLR effects experimentally excluded: fingerprints are
invariant under `setarch -R` and across repeated runs).
* Sequencing that one site by hand moved the first divergence to
#248,118 — the analogous `mk_ite(c, mk_select(...), mk_select(...))`
site in `array_rewriter.cpp`. Sequencing that one, too, moved it to
#248,411, inside `nnf:👿:process_iff_xor` — i.e. the next layer of
the same onion.
* With the whole `ast/rewriter` layer swept (this PR), the instrumented
builds produce **identical AST construction traces on both architectures
throughout the entire rewriter phase** of this 546k-line industrial
instance; the first divergence left is the NNF one.

### Fix

Following the precedent of 37904b9e8, e113d39aa, 360193098, 93ff8c76d,
9b88aaf13 ("parameter evaluation order", `bool_rewriter`/`seq_rewriter`)
and the existing comments in `seq_rewriter.cpp` ("introduce temporaries
to ensure deterministic evaluation order..."), this PR hoists
AST-creating arguments into named temporaries with a defined evaluation
order, across `src/ast/rewriter/` — 126 call sites in 17 files. The
transformation is purely sequencing: it selects one of the two valid C++
evaluation orders and makes it the same everywhere. (Temporaries are raw
pointers in rewriter-local scope, matching the precedent commits;
nothing can trigger GC between creation and consumption.)

The sites were found with a small AST-argument scanner (statement-level
call sites whose argument list contains ≥ 2 top-level arguments that
each contain an AST-creating call); I am happy to share/contribute the
script. Known remaining work, deliberately out of scope here to keep the
diff reviewable:

* 41 sites in `src/ast/rewriter/` that need manual treatment (inside
`if` conditions, ternaries, or multi-statement expressions) — list
available on request;
* `src/ast/normal_forms/nnf.cpp` (`process_iff_xor`, proven divergent by
the trace above), ~7 sites in `src/ast/simplifiers/`, ~3 in
`src/ast/converters/`, ~9 in `src/ast/`;
* other theory/solver layers (`src/smt/`, `src/sat/`, ...) — divergences
there only matter after search starts, where paths have usually already
split, but a full sweep would be needed for bit-reproducibility across
compilers.

Together with #10163, this is a step towards z3 builds whose behaviour
does not depend on the compiler or target architecture — which matters
for verification CI that runs identical proofs on heterogeneous
platforms and expects comparable runtimes.

---------

Co-authored-by: Kiro <kiro-agent@users.noreply.github.com>

src/ast/rewriter/seq_split.cpp

@@ -313,7 +313,11 @@ expr_ref seq_split::expand_fromre(expr* r, bool& ok) {
     if (rex.is_full_char(r) || rex.is_range(r) || rex.is_of_pred(r)) {
         const expr_ref ex(r, m);
         const expr_ref eps(rex.mk_epsilon(seq_sort), m);
-        return mk_union(mk_single(eps, ex), mk_single(ex, eps));
+        {
+            auto _seq316_0 = mk_single(eps, ex);
+            auto _seq316_1 = mk_single(ex, eps);
+            return mk_union(_seq316_0, _seq316_1);
+        }
     }
 
     // .* : sigma(.*) = { <.*, .*> }
@@ -391,8 +395,11 @@ expr_ref seq_split::expand_fromre(expr* r, bool& ok) {
         return mk_compl(mk_fromre(a));
 
     // difference: a \ b = a & ~b ; sigma(a \ b) = sigma(a) cap ~sigma(b).
-    if (rex.is_diff(r, a, b))
-        return mk_inter(mk_fromre(a), mk_compl(mk_fromre(b)));
+    if (rex.is_diff(r, a, b)) {
+        auto _seq0 = mk_fromre(a);
+        auto _seq1 = mk_compl(mk_fromre(b));
+        return mk_inter(_seq0, _seq1);
+    }
 
     // bounded loop / ite / other: not handled (paper "v1: bail").
     TRACE(seq, tout << "seq_split: unsupported regex " << mk_pp(r, m) << "\n";);
@@ -407,8 +414,11 @@ expr_ref seq_split::distribute_lcat(expr* r, expr* hs) {
         return mk_empty();
     if (is_single(hs, d, n))
         return mk_single(m_rw.mk_re_append(r, d), n);   // r.D
-    if (is_union(hs, a, b))
-        return mk_union(mk_lcat(r, a), mk_lcat(r, b));
+    if (is_union(hs, a, b)) {
+        auto _seq0 = mk_lcat(r, a);
+        auto _seq1 = mk_lcat(r, b);
+        return mk_union(_seq0, _seq1);
+    }
     UNREACHABLE();
     return expr_ref(hs, m);
 }
@@ -420,8 +430,11 @@ expr_ref seq_split::distribute_rcat(expr* hs, expr* r) {
         return mk_empty();
     if (is_single(hs, d, n))
         return mk_single(d, m_rw.mk_re_append(n, r));    // N.r
-    if (is_union(hs, a, b))
-        return mk_union(mk_rcat(a, r), mk_rcat(b, r));
+    if (is_union(hs, a, b)) {
+        auto _seq0 = mk_rcat(a, r);
+        auto _seq1 = mk_rcat(b, r);
+        return mk_union(_seq0, _seq1);
+    }
     UNREACHABLE();
     return expr_ref(hs, m);
 }