perf(thread saftey): All Engines are now thread safe

Previously engines were not thread safe, a seperate engine would be
needed for every thread. This is no longer the case. This allows for
much more efficient parallel execution

src/include/gridfire/engine/scratchpads/engine_adaptive_scratchpad.h

@@ -0,0 +1,135 @@
+/**
+ * @file engine_adaptive_scratchpad.h
+ * @brief Scratchpad implementation for the AdaptiveEngineView.
+ *
+ * This header defines the AdaptiveEngineViewScratchPad, a concrete implementation
+ * of AbstractScratchPad designed for use with the AdaptiveEngineView. It provides
+ * thread-local storage for active species and reactions that are dynamically
+ * determined during adaptive network computations.
+ *
+ * @par Purpose
+ * The AdaptiveEngineViewScratchPad stores:
+ * - The set of currently active species in the adaptive network
+ * - The set of currently active reactions based on network topology
+ * - Initialization state to track whether the scratchpad is ready for use
+ *
+ * @par Examples
+ * @code{.cpp}
+ * #include "gridfire/engine/scratchpads/engine_adaptive_scratchpad.h"
+ * #include "gridfire/engine/views/engine_adaptive.h"
+ *
+ * // Create and initialize the scratchpad from an AdaptiveEngineView
+ * gridfire::engine::scratch::AdaptiveEngineViewScratchPad scratch;
+ * AdaptiveEngineView engine = create_adaptive_engine();
+ * scratch.initialize(engine);
+ *
+ * if (scratch.is_initialized()) {
+ *     // Access active species for computation
+ *     for (const auto& species : scratch.active_species) {
+ *         // Process each active species
+ *     }
+ * }
+ *
+ * // Clone for parallel execution
+ * auto worker_scratch = scratch.clone();
+ * @endcode
+ *
+ * @par Thread Safety
+ * This class is **not thread-safe**. Each thread should have its own instance
+ * of AdaptiveEngineViewScratchPad. Use clone() to create independent copies
+ * for parallel workers.
+ *
+ * @see AbstractScratchPad
+ * @see AdaptiveEngineView
+ */
+
+#pragma once
+
+#include "gridfire/engine/scratchpads/scratchpad_abstract.h"
+#include "gridfire/engine/scratchpads/types.h"
+
+#include "gridfire/engine/views/engine_adaptive.h"
+
+namespace gridfire::engine::scratch {
+
+/**
+ * @brief Scratchpad for storing working memory used by AdaptiveEngineView computations.
+ *
+ * AdaptiveEngineViewScratchPad provides temporary storage for the active species
+ * and reactions determined by the adaptive network algorithm. This allows the
+ * engine to avoid recalculating network topology on every evaluation.
+ *
+ * @par Thread Safety
+ * This class is **not thread-safe**. Each thread should operate on its own
+ * independent instance. Use clone() to create copies for parallel execution.
+ */
+struct AdaptiveEngineViewScratchPad final : AbstractScratchPad {
+    /// @brief Unique identifier for this scratchpad type.
+    static constexpr auto ID = ScratchPadType::ADAPTIVE_ENGINE_VIEW_SCRATCHPAD;
+
+    /// @brief Flag indicating whether the scratchpad has been initialized.
+    bool has_initialized = false;
+
+    /// @brief Vector of species currently active in the adaptive network.
+    std::vector<fourdst::atomic::Species> active_species;
+
+    /// @brief Set of reactions currently active in the adaptive network.
+    reaction::ReactionSet active_reactions;
+
+    /**
+     * @brief Check whether the scratchpad has been initialized.
+     * @return true if initialized, false otherwise.
+     */
+    [[nodiscard]] bool is_initialized() const override { return has_initialized; }
+
+    /**
+     * @brief Initialize the scratchpad from an AdaptiveEngineView.
+     *
+     * Clears any existing state and prepares the scratchpad for use.
+     * This method is idempotent; calling it multiple times has no effect
+     * after the first successful initialization.
+     *
+     * @param engine The AdaptiveEngineView to initialize from.
+     *
+     * @par Examples
+     * @code{.cpp}
+     * AdaptiveEngineViewScratchPad scratch;
+     * AdaptiveEngineView engine = create_engine();
+     * scratch.initialize(engine);
+     * @endcode
+     */
+    void initialize(const AdaptiveEngineView& engine) {
+        if (has_initialized) return;
+        active_species.clear();
+        active_reactions.clear();
+        has_initialized = true;
+    }
+
+    /**
+     * @brief Create a deep copy of this scratchpad.
+     *
+     * Creates an independent copy of all internal state, including
+     * active species and reactions. The clone can be modified without
+     * affecting the original.
+     *
+     * @return A unique pointer to the cloned scratchpad.
+     *
+     * @par Examples
+     * @code{.cpp}
+     * auto original = std::make_unique<AdaptiveEngineViewScratchPad>();
+     * original->initialize(engine);
+     *
+     * // Create independent copy for a worker thread
+     * auto worker_copy = original->clone();
+     * @endcode
+     */
+    std::unique_ptr<AbstractScratchPad> clone() const override {
+        auto ptr = std::make_unique<AdaptiveEngineViewScratchPad>();
+        ptr->has_initialized = has_initialized;
+        ptr->active_species = active_species;
+        ptr->active_reactions = active_reactions;
+        return ptr;
+    }
+};
+
+} // namespace gridfire::engine::scratch