It's tough to debug issues when you can't run on the same hardware directly.
There's a reason that arm support in open source software has exploded in the past few years, and it's because of apple silicon.
I'll agree that it's easier now, with most developers using higher level runtimes, but someone's got to get those runtimes working, and it's much easier to develop if you have a laptop running that hardware.
Why leave paradise?
That line stuck out to me as well -- the law isn't some holy Grail of ethics, it's literally the bare minimum.
Functions are fine, don't move to struct impls unless it makes sense (but do if the functions all take the same struct as a param).
You can go pretty far with modules and functions. Group related functions and move them to new modules. You can also hide functions that are only used inside one of the submodules by just not marking them as pub.
One thing that comes to mind is that if the steps of your algorithm all take and return the same data, you can have a trait that expresses that (possibly one of the Fn traits if you're going to just use functions), and you can define and rest each step separately.
It's hard to give more concrete advice without knowing more about your project
Just FYI -- your test isn't going to run, you need to mark it with #[test].
So if you're used to a language like JS or python, or even Java, you're going to be a bit frustrated at how to mock things in rust. In those languages everything is boxed. In JS or python, because they're dynamically typed, you don't have to do anything special to mock, and in Java you can either play nice and use interfacees everywhere, or else you can do some runtime magic to mock an object of a regular class.
You can do something similar in rust -- e.g. you can have a trait Cat and a struct RealCat and a (or possibly many) struct FakeCat. (There are crates that will help you with this). Then you need to either accept a Box or a &dyn Cat, or make your code under test generic (which can infect the rest of your code if you aren't careful), something like fn uses_a_cat(cat: C) {}
So there's not quite as easy of an answer. You also have several more options, for example you can
pub struct FakeCat;
pub struct RealCat;
#[cfg(test)]
pub type Cat = FakeCat;
#[cfg(not(test))]
pub type Cat = RealCat;
and get a fake (or mock, or spy, whatever test double you'd like) in all test code in your same crate. This doesn't work well across crate boundaries though, and it only lets you provide one double, so it makes sense for that double to be very generic (there are crates to do this for you as well).
So there's not really a one-size-fits-all approach. You have to think about the tradeoffs.
However I think the best overall test strategy (and it doesn't always apply, but it should be preferred when it does), is the same one used for functional programming: just accept and return values. Pure functions don't need mocks, and even impure functions can easily be tested if they don't have other side effects that you need to prevent during tests. Obviously you still need to deal with side effects if your program is going to work, but if you have lots of pure unit tests that don't need any fancy test doubles you can do end-to-end testing for all of your I/O and other messy side effects. Which as I said, doesn't always apply (sometimes you really need test doubles), but it's good to use whenever possible.
And this isn't even the expensive part -- training, this is just inference.
Can't wait for this fad to be over
Pocket casts has a webapp that works pretty well.
Not sure if you need to pay for it though, I'm grandfathered in