PR: Integrate Rust Cairo VM Runner with Proof Mode into Python Testing Framework

Closes #952
Closes #960

Overview

This pull request further pushed the functional parity between the Rust-based Cairo VM runner (PyCairoRunner) and the existing Python VM runner (run_python_vm) by adding support for Proof Mode.

Key changes include a refactored runner.py file with an 8-step structure, mirrored in both vm runs, extended Rust bindings in runner.rs.

Changes

1. Refactored run_rust_vm in runner.py

   • Objective: Mirror the 8-step structure of run_python_vm for consistency and maintainability.
   • Details:
     • Step 1: Program selection and entrypoint metadata extraction using build_entrypoint.
     • Step 2: Runner initialization with RustCairoRunner, supporting proof mode and layout configuration.
     • Step 3: Stack construction with builtins and arguments, integrating gen_arg_builder for type conversion.
     • Step 4: VM setup done in python rather than in Rust
     • Step 5: Execution via run_until_pc with exception handling and coverage support.
     • Step 6: Return value processing with read_return_values, proof mode updates, and security verification.
     • Step 7: Output file generation (trace, memory) using Rust methods, with proof mode leveraging the Rust approach (e.g., write_binary_trace, write_binary_memory).
     • Step 8: Output serialization via Serde, matching Python VM behavior.
   • Impact: Ensures a modular, debuggable flow aligned with run_python_vm, while respecting Rust’s proof mode handling. Both jmp rel 0 "hacks" are applied to both vm runs.

2. Enhanced PyCairoRunner in runner.rs

   • Objective: Extend Rust bindings to support all execution phases and proof mode outputs.
   • Details:
     • Modified initialize_vm to not handle stack setup, which is now handled in python.
     • Implemented execution methods: run_until_pc, verify_auto_deductions, read_return_values, verify_secure_runner, relocate, to be closer from the python vm runner
     • Added getters for state inspection: initial_pc, initial_ap, initial_fp, program_base, execution_base, ap, relocated_trace, trace_df.
     • Introduced proof mode output methods: finalize_segments, write_binary_trace, write_binary_memory, update_execution_public_memory.
     • Kept write_binary_air_public_input and write_binary_air_private_input for Rust-native AIR file generation (per your decision to retain the Rust approach).
   • Impact: Provides a robust Rust API for Python to control execution and generate proof mode artifacts natively.

Rationale

• Parity: The 8-step structure ensures run_rust_vm behaves like run_python_vm, easing contributor onboarding and maintenance by clearly defining the rational behind each step.
• Constraints: Retained existing Rust APIs (e.g., write_binary_air_*) per project limitations, delegating AIR file details to Rust where applicable.

Testing

• Verified execution parity with run_python_vm on sample Cairo programs. (test_rlp.py)
• Verified execution was working in proof mode for EF-Tests
• DID NOT Try to verify a produced proof.