fix(tests): generate storage-only scalar fixtures via run(), not run_sampled()

The catalog-driven fixture dispatch emitted
`eql_v2_<T>::spec().run_sampled().await` for EVERY token. run_sampled()
requires `T: RandomPlaintext`, which is implemented only for the seven
comparison scalar plaintext types — `bool` (storage-only, no `_eq`/`_ord`,
no comparison corpus to randomize) deliberately has no impl. So adding the
`bool` row to the dispatch list (eql_v3_bool, #295) and switching the
dispatch to the randomized corpus (property-tests work) were each green in
isolation but broke when combined:

  error[E0277]: the trait bound `bool: RandomPlaintext` is not satisfied
   --> tests/sqlx/tests/generate_all_fixtures.rs:23  (scalar_types!(fixture_dispatch))

failing test:sqlx:prep -> fixture:generate:all in build-archive and the new
e2e job.

Route storage-only tokens to run() (fixed curated values, only needs
FixtureValue) and keep run_sampled() for comparison-capable scalars. The
macro already classifies storage-only via is_storage_only_token; this reuses
it. Adds dispatch-routing assertions to the bool unit test.

Verified: cargo test -p eql-tests-macros (20/20) and a --no-run compile of
the generate_all_fixtures target (E0277 gone).

Author: tobyhede

crates/eql-tests-macros/src/lib.rs

@@ -275,8 +275,18 @@ fn fixture_dispatch_tokens(list: &ScalarList) -> TokenStream2 {
     let arms = list.entries.iter().map(|e| {
         let token_str = e.token.to_string();
         let mod_ident = format_ident!("eql_v2_{}", e.token);
+        // Storage-only scalars (`bool`) carry no comparison corpus to randomize
+        // and deliberately have no `RandomPlaintext` impl (the trait is for the
+        // comparison scalars only), so generate their fixed curated values via
+        // `run()`. Comparison-capable scalars get the randomized
+        // `mandatory ∪ random ∪ duplicates` corpus via `run_sampled()`.
+        let gen_method = if is_storage_only_token(&token_str) {
+            format_ident!("run")
+        } else {
+            format_ident!("run_sampled")
+        };
         quote! {
-            #token_str => ::eql_tests::fixtures::#mod_ident::spec().run_sampled().await,
+            #token_str => ::eql_tests::fixtures::#mod_ident::spec().#gen_method().await,
         }
     });
     quote! {
@@ -648,6 +658,20 @@ mod tests {
         assert!(suites.contains("caps = [storage]"));
         let dispatch = norm(&fixture_dispatch_tokens(&list));
         assert!(dispatch.contains(r#""bool" =>"#));
+        // A storage-only scalar has no comparison corpus to randomize and no
+        // `RandomPlaintext` impl, so its fixture is generated from the fixed
+        // curated values via `run()`. Comparison-capable scalars use the
+        // randomized `run_sampled()` corpus.
+        assert!(
+            dispatch.contains(
+                r#""bool" => :: eql_tests :: fixtures :: eql_v2_bool :: spec () . run () . await"#
+            ),
+            "storage-only bool must dispatch to run(), got: {dispatch}"
+        );
+        assert!(
+            dispatch.contains(r#""int4" => :: eql_tests :: fixtures :: eql_v2_int4 :: spec () . run_sampled () . await"#),
+            "comparison-capable int4 must dispatch to run_sampled(), got: {dispatch}"
+        );
     }
 
     #[test]