Feat/disk cache (#354)

- Bump rust version to `nightly-2025-07-02` because some of the nightly features we were using have been stabilized.
- Introduce feature `disk_cache` which enables caching to disk.  Each time an artifact is retrieved from the cache it will be read and deserialized.  On a cache miss the artifact will be created, serialized and stored to disk.
- Introduce feature `mem_cache` which enables caching to memory.  All cached artifacts are kept in memory after they are created.  The mem cache implementation avoids cloning of artifacts by extending their lifetime to `'static`.  This is `unsafe` code, but I argue that this usage is safe.
- Add a `build.rs`
  - When the feature `disk_cache` is enabled, the `build.rs` will inject env variables to the process with the git commit information, which is used to index the cached artifacts
- Replace all previous cached artifacts from `LazyStatic` methods that call the cache API
- Derive `Serialize, Deserialize` for all `*Target` types so that they can be serialized for caching to disk
- Add finer level of caching: now we cache the `CircuitData` and `VerifierData` independently.  The reason for this is that `CircuitData` is a very big artifact which is not needed for verification.  So by only accessing `VerifierData` in verification we don't pay a big overhead for reading from disk and deserializing
- Add missing artifacts to the cache: like the `CircuitData` for the `MainPod` indexed by `Params`
- Add helper types to serialize and deserialize `CircuitData`, `CommonData` and `VerifierData` with the set of gates and generators used in the recursive MainPod circuit
- Tweak the ids of our custom gates so that they remain unique when their generic parameters change
- Bugfix: several tests were using the standard `vd_set` but were using MainPod circuits with non-default parameters.  This was working before because there was a bug: the MainPod circuit was reporting that the used verifier data was the standard one instead of picking the one corresponding to it's own Params.

Summary of breaking changes:
- One and only one of the features `mem_cache` or `disk_cache` need to be enabled.  By default it's `mem_cache`
  - To enable the `disk_cache` you need to disable the default features like this: `--no-default-features --features=backend_plonky2,zk,disk_cache`
- Removed `DEFAULT_PARAMS`, instead use `Params::default()`
- Removed `STANDARD_REC_MAIN_POD_CIRCUIT_DATA`, instead use `cache_get_standard_rec_main_pod_common_circuit_data`
- The library is now using `nightly-2025-07-02`.  Some rust language features are unstable in previous versions.

src/backends/plonky2/mod.rs

@@ -6,39 +6,46 @@ pub mod mainpod;
 pub mod mock;
 pub mod primitives;
 pub mod recursion;
+mod serialization;
 pub mod signedpod;
 
-use std::sync::LazyLock;
-
 use base64::{prelude::BASE64_STANDARD, Engine};
 pub use error::*;
 use plonky2::util::serialization::{Buffer, Read};
 
 use crate::{
     backends::plonky2::{
-        basetypes::{CircuitData, CommonCircuitData, Proof},
+        basetypes::{CommonCircuitData, Proof},
         circuits::mainpod::{MainPodVerifyTarget, NUM_PUBLIC_INPUTS},
         recursion::RecursiveCircuit,
+        serialization::CommonCircuitDataSerializer,
     },
+    cache::{self, CacheEntry},
     middleware::Params,
     timed,
 };
 
-pub static DEFAULT_PARAMS: LazyLock<Params> = LazyLock::new(Params::default);
-
-pub static STANDARD_REC_MAIN_POD_CIRCUIT_DATA: LazyLock<CircuitData> = LazyLock::new(|| {
-    let params = &*DEFAULT_PARAMS;
-    timed!(
-        "recursive MainPod circuit_data",
-        RecursiveCircuit::<MainPodVerifyTarget>::target_and_circuit_data(
-            params.max_input_recursive_pods,
-            NUM_PUBLIC_INPUTS,
-            params
-        )
-        .expect("calculate circuit_data")
-        .1
+pub fn cache_get_standard_rec_main_pod_common_circuit_data(
+) -> CacheEntry<CommonCircuitDataSerializer> {
+    let params = Params::default();
+    cache::get(
+        "standard_rec_main_pod_common_circuit_data",
+        &params,
+        |params| {
+            let circuit_data = timed!(
+                "recursive MainPod circuit_data",
+                RecursiveCircuit::<MainPodVerifyTarget>::target_and_circuit_data(
+                    params.max_input_recursive_pods,
+                    NUM_PUBLIC_INPUTS,
+                    params
+                )
+                .expect("calculate circuit_data")
+            );
+            CommonCircuitDataSerializer(circuit_data.1.common)
+        },
     )
-});
+    .expect("cache ok")
+}
 
 pub fn serialize_bytes(bytes: &[u8]) -> String {
     BASE64_STANDARD.encode(bytes)