make the HolonContext object a shared read, single write singleton

[nphias]

Instead of passing the HolonContext down the stack in function/method arguments and then passed back up again to the reference layer, where it is actually invoked (see test 6 related_holons / holon collections), have it created once during initialization and then available as a singleton to the reference layer whenever needed.
example code:

use lazy_static::lazy_static;
use std::sync::{Arc, Mutex};

struct MySingleton {
    pub value: i32,
}

impl MySingleton {
    fn new(value: i32) -> Self {
        MySingleton { value }
    }
}

lazy_static! {
    static ref SINGLETON: Arc<Mutex<MySingleton>> = Arc::new(Mutex::new(MySingleton::new(42)));
}

fn main() {
    let singleton = SINGLETON.clone();
    {
        // Access and modify the singleton
        let mut instance = singleton.lock().unwrap();
        println!("Initial value: {}", instance.value);
        instance.value += 10;
    }

    // Access the singleton again
    let singleton_again = SINGLETON.clone();
    {
        let instance = singleton_again.lock().unwrap();
        println!("Updated value: {}", instance.value);
    }
}

[evomimic]

It's unclear what problem is being addressed here. The context object serves as a container for shared session and request state. A reference to it (not the context object itself) is being passed down the call stack. This makes it clear what methods depend upon the context and which don't. If we discover additional state that needs to be available, we can add it to the struct definition, without having to change any signatures.

Why is any of this problematic?