Manually passing context is reasonable in many cases (I mean it's the default way we pass things!) and I can totally see how this future could be abused, but that doesn't mean that scenarios where this feature is invaluable don't also exist!
All languages need to pass some amount of context around. In most other languages, that isn't that big of a problem since, after a given piece of context is given to a subsystem, they can stash a reference to it that they can reuse for all subsequent method calls. However, in Rust, stashing a reference to a subsystem comes with a significant penalty: to mutate that object, you are now forced to employ interior mutability. Likewise, dynamic dependency injection only really works if either a) you're fine with borrowing objects at bundle granularity or b) you're fine with making every single component of your bundle immutable.
And that's super unfortunate since plenty of patterns require granular exterior mutability to function and that makes those patterns impossible to effectively dependency inject. One such pattern I absolutely love is the generational arena, which I gave as an example in the neat examples section of the project README. This pattern is essentially magic: it gives you a way to emulate shared mutable references which can be freely copied and destroyed without requiring any sort of runtime borrow-checking.
I do sympathize with the potential usage hazards this feature may introduce but I do think that the benefit of reducing our dependence on runtime borrow checking and replacing it with a compile-time checked alternative is highly compelling. Implementing this feature makes the borrow checker considerably more powerful without really changing any of its core analyses.
Interior mutability does not obviate the problem of spooky action at a distance—it just hides it until runtime, ultimately limiting the types of APIs we can safely borrow check. A similar thing can be said about the solution of manually passing everything as a parameter. Doing this doesn't prevent spooky action distance, it just means that every time the user wants to use some context deep in a function chain, they have to manually update the signature of all ancestor functions—essentially replacing automated SAAD with tedious manual SAAD.