pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
        #[cfg(all(multi_core, low_power_wait))]
        unwrap!(esp_hal::interrupt::enable(
            esp_hal::peripherals::Interrupt::FROM_CPU_INTR3,
            Priority::min(),
        ));

        self.inner.init();

        init(self.inner.inner.spawner());

        #[cfg(low_power_wait)]
        let cpu = Cpu::current() as usize;

        loop {
            unsafe { self.inner.inner.poll() };

            #[cfg(low_power_wait)]
            Self::wait_impl(cpu);
        }
    }
Run the executor.

The `init` closure is called with a [`Spawner`] that spawns tasks on
this executor. Use it to spawn the initial task(s). After `init`
returns, the executor starts running the tasks.

To spawn more tasks later, you may keep copies of the [`Spawner`] (it is
`Copy`), for example by passing it as an argument to the initial
tasks.

This function requires `&'static mut self`. This means you have to store
the Executor instance in a place where it'll live forever and grants
you mutable access. There's a few ways to do this:

- a [StaticCell](https://docs.rs/static_cell/latest/static_cell/) (safe)
- a `static mut` (unsafe, not recommended)
- a local variable in a function you know never returns (like `fn main()
-> !`), upgrading its lifetime with `transmute`. (unsafe)

This function never returns.
esp-hal-embassy/src/executor/thread.rs