Cardano Updates

  The code is sufficiently complexe already, and the addition of the
  source map context makes it a bit more. That's okay. But duplicating
  entire chunks of logic with no changes when we have generics, is not!

  There's a similar cleanup to be done around the 'coverage' command,
  which is, in most part, a duplicate of the `check` command.

  Note that this changes also drop the 'finalize_minimal' and make the
  `no_optimize` flag now unused. It is not a mistake. That flag should
  not exist and shall be removed in upcoming commits.

Signed-off-by: KtorZ <[email protected]>

1. Preserve term context through DeBruijn round-trip in optimizer
   (afterwards, run_once_pass) by collecting and restoring contexts
   instead of replacing with C::default().

2. Fix source-map index stability by visiting function before argument
   in Apply traversal, so wrapping a term doesn't shift existing indices.

3. Propagate fuzzer sampling errors in coverage instead of silently
   breaking, which could produce false success with empty reports.

4. Aggregate property test iterations by base name for fail-once
   semantics — the property passes if ANY iteration fails, not each
   independently.

5. Include configured directory prefix in sourceMapFile references so
   they resolve relative to the blueprint location.

- Add is_empty() method to Env (len_without_is_empty)
- Allow type_complexity in builtin_curry_reducer
- Remove redundant iter cloning in script_context.rs

I had a different rust version locally so therese weren't showing up.

- Used derive(Default) on SourceLocation
- Allow some unused assignments, because they're used by
  miette
- Add result_large_err to existing allow attribute

Fix 1: Source map path bug (lib.rs:798)

  Problem: validator.title can contain slashes from nested module paths (e.g.
  governance/voting.my_vote.spend). When used directly as a filename in
  dir.join(), the slash creates nested subdirectories. Since only dir was
  created with create_dir_all, the intermediate directories don't exist and
  fs::write fails.

  Fix: Replace / with - in the validator title before constructing the
  filename:
  let safe_title = validator.title.replace('/', "-");
  let filename = format!("{}.sourcemap.json", safe_title);

  This produces flat filenames like
  governance-voting.my_vote.spend.sourcemap.json.

  Fix 2: Coverage property test iterations (lib.rs:615-670)

  Problem: property_max_success was ignored (prefixed with _) and property
  tests were only sampled once during coverage, missing code paths that only
  get exercised with different fuzzer inputs.

  Fix:
  - Renamed _property_max_success back to property_max_success and threaded it
   through to collect_tests_for_coverage
  - Replaced the single-sample logic with a loop that chains the PRNG state
  across property_max_success iterations, generating a separate test program
  for each sampled value
  - Each iteration's coverage gets merged into the aggregate, giving proper
  coverage reporting across all fuzzer inputs

- Add #[allow(clippy::too_many_arguments)] to a few functions
- Rename to_string() to render()
- Add #[allow(clippy;type_complexity)] to collect_tests_for_coverage
- Fix a few unused variables
- Remove unused imports
- Fix needless_borrow in export command
- Use arrays instead of vec![] in tests
- Use !is_empty() instead of len() > 0

Operates identically to the test command, but prints out a coverage
report, using the new source map capabilities!

This should avoid bugs with diverging implementations, the recurring
theme of this PR.

Allows us to do compilation and codegen, but skip any optimizations that might screw with the execution codepath, making it easier to debug a contract

Adds a field to sourcemaps that map var's and lambdas to the variable
names that introduce them; this lets debuggers show original source variable
names in the environment!

Thread SourceLocation through the code generation to all UPLC term
construction sites, including:
- Assignments and let bindings
- Boolean operators (and/or chains)
- Function application

Exposes an interface to run the CEK machine one step at a time
(essentially just exporing a few functions);

More importantly, Now that we've added Context to terms, and propagated that through
compilation, when we *run* the machine, we have to erase the context
down to unit ().

This makes things like debugger support awkward, because as the machine
executes, the term being executed gets manipulated. That means to map it
back to the generated source maps, we'd need some kind of pattern
matching system.

So, instead if we update the Machine to be able to run generically over
context (i.e. preserve the context as we juggle the CEK machine), then
we can use that context to attach a post-order numbering to each node,
and use that to index into the source maps.

To that end, we add a context parameter to Value, BuiltinRuntime, and
Env.

Of note, we don't make Error generic over Context. While that might be
useful for better error messages on failure, it's a much bigger
refactor, and isn't critical for debugging steps; so for now, we just
erase the context when constructing errors, and provide a utility for
lifting Value<()> into the default context.

This now passes the location information we have down into the Term!

It's not *super* useful yet; the things generated by the compiler that
*should* be able to derive their span info from the things around them
aren't yet being provided; but it's a good start, all the tests pass!

For example, here's a little fibonacci test I put together:

=== Source code ===

          fn fib(n: Int) -> Int {
            if n < 2 {
              n
            } else {
              fib(n - 1) + fib(n - 2)
            }
          }

          test fib_test() {
            fib(10) == 55
          }

    === Term tree with source locations ===
    Apply (no span)
      Apply (no span)
        Builtin(EqualsInteger) (no span)
        Apply (no span)
          Apply (no span)
            Lambda(test_module_fib) (no span)
              Apply (no span)
                Lambda(test_module_fib) (no span)
                  Var(test_module_fib) @ 164..167 = "fib"
                Apply (no span)
                  Var(test_module_fib) (no span)
                  Var(test_module_fib) (no span)
            Lambda(__no_inline__) (no span)                                                 Lambda(test_module_fib) (no span)
                Lambda(n_id_0) (no span)
                  Force (no span)
                    Apply (no span)
                      Apply (no span)
                        Apply (no span)
                          Force (no span)
                            Builtin(IfThenElse) (no span)
                          Apply (no span)
                            Apply (no span)
                              Builtin(LessThanInteger) @ 42..47 = "n < 2"
                              Var(n_id_0) @ 42..43 = "n"
                            Constant(Integer(2)) (no span)
                        Delay (no span)
                          Var(n_id_0) @ 60..61 = "n"
                      Delay (no span)
                        Apply (no span)
                          Apply (no span)
                            Builtin(AddInteger) (no span)
                            Apply (no span)
                              Apply (no span)
                                Var(test_module_fib) @ 89..92 = "fib"                                         Var(test_module_fib) @ 89..92 = "fib"
                              Apply (no span)
                                Apply (no span)
                                  Builtin(SubtractInteger) @ 93..98 = "n
    - 1"
                                  Var(n_id_0) @ 93..94 = "n"
                                Constant(Integer(1)) (no span)                                          Apply (no span)
                            Apply (no span)
                              Var(test_module_fib) @ 102..105 = "fib"                                       Var(test_module_fib) @ 102..105 = "fib"
                            Apply (no span)
                              Apply (no span)
                                Builtin(SubtractInteger) @ 106..111 = "n
    - 2"
                                Var(n_id_0) @ 106..107 = "n"
                              Constant(Integer(2)) (no span)
          Constant(Integer(10)) (no span)
      Constant(Integer(55)) (no span)

Spans aren't sufficient to actually track source location; we were
trying to match based on module, but inlining messes with that.

So, we'll pass the source file name in all the way through, and we
introduce a SourceLocation type for this.

- Add SourceMap type for mapping UPLC node indices to source locations
- Add the ability to generate a sourcemap when building, either
  externally or in the blueprint json
- Supports exporting tests (useful as a source of complex examples)
- Add's a --list flag to make identifying what exactly to export easier

It doesn't do us much good to carry the source spans through the whole
compilation process, if optimizations just screw with the UPLC tree at
the end.

This ensures that the interning, shrinking, and other optimizations
carry through the relevant context.

This also fixes the order of operations to apply used functions before
optimization.

- Add more source spans during code generation
- Reorder pipeline to ensure source maps survive optimization
- Unify the codegen paths to always use generic context

Adds a new location field to Air and AirTree node variants, intended to
track the closest span in the source code that generated that node.
Initially set to empty spans, but then we can add in more and more
source coverage in future commits.

Adds a generic "Context" parameter that can be populated with data; any
methods which work with terms will preserve the context, meaning it
survives execution, optimization, etc.

For now, we default it to (), but this is foundational work for source
map support, because we can assign sourcemap locations as the context
during codegen.

  Clippy has gotten 'smarter' at detecting unused fields, but at the same time, it's now not able to correctly detect usage over miette's diagnstic macros... So I've turned off the warning for now.

Signed-off-by: KtorZ <[email protected]>

  Mostly impacting value reification and tracing of large negative integers.

Fixes #1241
Signed-off-by: KtorZ <[email protected]>