Cardano Updates

+ Move `credsNeeded` to ScriptValidation
+ Refactor `getDatum`
+ Rename premises in UTxOw

Clean up the project structure, remove dead code, and group related functions more logically without changing the pipeline's overall behavior.

This refactoring replaces large, imperative `try-except` blocks with collections of
smaller, pure, testable functions composed in a robust chain. It's a significant
improvement in the clarity and reliability of the Agda processing stage.

+  Functions in `modules/` orchestrate the pipeline logic. They describe *what* to do
and should be free of `try-except` blocks for I/O. They operate on `Result` objects.

+  Functions in `utils/` provide reusable tools that perform the "impure" work. They
   are the "boundary" and use `try-except` internally to convert exceptions into `Err`
   values.

+  Move pure logic to utility modules.
+  All functions in `postprocess.py` that perform text replacements are pure
   transformations; move them to `utils/text_processing.py`, making them reusable
   utilities. To make them truly pure, modified them to accept data (like code
   blocks and label maps) as arguments instead of relying on global variables.
+  Update Pipeline Orchestrator. Add new function to `modules/latex_pipeline.py` that
   orchestrates these post-processing steps.  Replaces old method of calling
   `postprocess.py` as an external script, which eliminates a `subprocess` call and
   integrates the logic seamlessly.
+  Delete Legacy Script. `postprocess.py` is now retired.
+  Add new `utils/file_ops.py` utility module including directory functions from `setup.py`.
+  Merge `asset_generator.py` into `site_assembly.py`, since `site_assembly.py` already uses functions from `asset_generator.py`.
+  Clean up `build_config.py` (remove `get_legacy_paths()`---it's now dead code)
+  Error handling is now more precise: it skips files that are missing their
   intermediate parts (a recoverable issue) but will correctly halt the entire build on
   a more serious problem (like a permissions error when writing the final file).
+  More specific exceptions. The functions now catch `OSError` for file system
   permission issues, which is more descriptive than a generic `Exception`.
+  Cleaner Logic. functions are now simpler and no longer returns a `Result`, as a
   `FileNotFoundError` is not a critical failure for this specific task—it simply means
   the file size is 0.

1.  **Correct Usage (Boundary Functions):** The `try` blocks in
    `utils/command_runner.py` and `utils/file_ops.py` are fine; they serve as the
    necessary bridge between impure libraries (`subprocess`, `shutil`) and our
    functional code. These should stay.

2.  **Candidates for Refactoring (Orchestration Logic):** Most other `try` blocks,
    especially those in the `modules/` directory, are wrapping larger chunks of logic.
    These are prime candidates for refactoring. Instead of a large `try...except` block,
    these functions should be chains of smaller operations that each return a `Result`.

+  No `try-except`. The main logic is now free of explicit exception handling. All
   I/O error handling is delegated to the `ls_dir` utility.
+  Clarifies Error Handling.  The `calculate_file_metadata` function remains a good
   example of a case where a local `try-except` is a valid choice because the goal is
   to **provide a default value**, not to halt the entire pipeline on failure. This
   distinguishes it from critical I/O operations where failure must be propagated.
+  Declarative. The code now reads like a description of what it does ("list the
   directory and then map the result to processed files") rather than a sequence of
   imperative steps.
+  Preserves Behavior. Because our `calculate_file_metadata` function already handles
   its own `FileNotFoundError` by returning a default value, the mapping operation
   `[... for p in paths]` is safe and won't crash the whole pipeline if one file has
   an issue, perfectly preserving the logic of your original implementation.

+  `build-tools/scripts/md/modules/site_assembly.py`
   handles all final steps: copying staged content, deploying all assets (CSS, JS, BibTeX), and generating the final `mkdocs.yml`.

+  `build-tools/scripts/md/modules/content_staging.py`
   prepares the processed markdown files for the site assembly step.