std::futures is the core futures functionality needed to implement async/await syntax.
futures-rs is a crate which adds utility and abstraction over futures:
SinkExt. You don't need them for async programming, but they would be usefull (stream and guys probably the most), also some synchronization primitives.
Tokio brings an async runtime (some runtime is needed to execute futures), and some additional utility to handle with environment in async way: IO, time, unix signals, also synchronization primitives (some of them provided by futures-rs, some not). Tokio is build on futures-rs, but it exports things it uses, so there is no need to depend on futures-rs if you are not using additional things which tokio doesn't reexport.
There is also async-std which want to bring API very similar to standard lib, but for async programming - somehow like futures-rs and tokio merged together. It uses different executor than tokio. I don't know which one is better, but for sure I know that there are things which there are not in async-std, but they are in futures-rs.
About your usecase - I don't see a question. You found correct tools to do this, you will just need a runtime for your async code (probably tokio or async-std). The question is if this is a good choise to do this as async code - if all your futures are just cpu-bound calculations, and you want split them on thread this way, it is probably not - rayon and traditional concurrency is a way to go. Keep in mind, that "concurrent" is not the same as "parallel". Async programming is a tool for avoiding busy-waiting for things which are not there (so for example for handling network connections, maybe some kind of input, or reading huge files). It doesn't do well with typical parallel execution, cause executor and futures are just an extra overhead.