Add Transport object for class/process/module/singleton

[Eein]

the files can get messy, and we want to return these items to the functions, so the proposal is a transport struct for these unwrapped values For example:

impl MemoryManagerUpdate for TitleSequenceManagerData {
    fn update(
        &mut self,
        ctx: &StateContext,
        manager: &mut UnityMemoryManager,
    ) -> Result<(), Error> {
        if let Some(class) = manager.class {
            if let Some(process) = &ctx.process {
                if let Some(module) = &ctx.module {
                    if let Some(singleton) = manager.singleton {
                        self.update_current_screen_name(ctx, manager)?;
                        self.update_title_menu(ctx, manager)?;
                        self.update_pressed_start(ctx, manager)?;
                        self.update_load_save_done(ctx, manager)?;
                        self.update_relics(ctx, manager)?;
                        self.update_new_game_characters(ctx, manager)?;
                    }
                }
            }
        }
        Ok(())
    }
}

could be:

impl MemoryManagerUpdate for TitleSequenceManagerData {
    fn update(
        &mut self,
        ctx: &StateContext,
        manager: &mut UnityMemoryManager,
    ) -> Result<(), Error> {
        let context = MemoryContext::create(manager, &ctx)?;

        self.update_current_screen_name(context)?;
        self.update_title_menu(context)?;
        self.update_pressed_start(context)?;
        self.update_load_save_done(context)?;
        self.update_relics(context)?;
        self.update_new_game_characters(context)?;

        Ok(())
    }
}

struct MemoryContext {
    class: Class,
    process: Process,
    module: Module,
    singleton: Class
}
impl MemoryContext {
    fn create(manager, & ctx) {
        if let Some(class) = manager.class {
            if let Some(process) = &ctx.process {
                if let Some(module) = &ctx.module {
                    if let Some(singleton) = manager.singleton {
                        Self { class, process, module, singleton }
                    }
                }
            }
        }
    }

• [ ] create memory context
• [ ] implement read functions for the memory context (follow_fields, read_pointer) that hide the internals from the user.

[orkaboy]

Maybe add something to impl MemoryContext so we can read from it directly instead of using its members.