That is just a matter of perspective I would say. Installing in Windows used to be simpler in comparison, but recently I think the Linux way is actually simpler. Look up a package in package manager, tell package manager you want the package installed, and then it downloads the package for you, installs it, sets it up, and keeps it up-to-date for you... All of it is automated, very simple to use. As long as the package is part of the distro's repos, it's probably going to be very very easy to install. (If it's not, then it depends.) On Windows, in constrast, you have to obtain an installer, run it granting it admin privileges, click through several screens, uncheck installation of Ask Toolbar or somesuch... And then the udate process (or rather thereof) is whole another matter...
Linux isn't hard or uncomfortable, at least not anymore. It's just different / unfamiliar...
I think you are biting off way too much. First, your choice of Rust: you say you chose it because of memory safety and it runs on multiple platforms. Do you understand that there are multiple ways to achieve memory safety and Rust is the most difficult in terms of the burden it places on the programmer? Garbage collected languages like Go, Nim, Haskell, Ocaml, etc., all run on a variety of platforms and provide memory safety (and compile-time type safety due to static typing) without getting you into the demands that Rust will make on you. I have written code in most of the languages I've cited, as well as Rust, and I am a deeply experienced programmer (=old) and Rust is by far the most difficult to master and there are some things that are almost impossible to do in Rust (see the thread I started on caching prepared sqlite statements; I got a lot of help from some smart people who contribute to this list and I've finally concluded that it just isn't worth it, as well as concluding that doing this without static global state, at least with the sqlite crate, is impossible, whereas it is trivial in any of the other languages I cited; I should probably send another message to that thread explaining why I reached that conclusion). So unless you have a specific reason for needed memory safety without a garbage collector, I would avoid Rust, given your long hiatus from programming. If you haven't driven a car in a long time, a Formula One car is not the way to become reacquainted. And almost no one needs a Formula One car for daily transportation (where would you put the groceries?).
I would also comment that while memory safety and thread safety are important, the most challenging part of programming is at the forest level, not the trees. Properly organizing a large piece of software is difficult and getting the algorithms right is essential for good performance. In most cases, the latter has a greater influence on the ultimate performance of your application than the particular language you choose, especially on today's hardware, unless you try to do something that is inherently computationally very intense in an interpreted language. I would recommend reading Structure and Interpretation of Computer Programs (Sussman, Abelson and Sussman) for an eye-opening course on how to use abstraction techniques to divide and conquer the problem of software organization. I'm not necessary advocating using Scheme, though you could do worse (I highly recommend Chez Scheme -- open-source (now), rock-solid and very fast). Most of the techniques discussed in that book are not language-specific.
Second: Linux. I'd recommend Debian. I'm typing this on an Arch system, but the comments about Arch (by HadrienG) are right on the mark. Sometimes the rolling release strategy will result in breakage. Debian is extremely stable and not as bloated as Mint (Mint is based on Ubuntu which is based on Debian). You won't get the latest and greatest version of everything, but you can compile things from source or load static binaries in some cases to get later versions of things where that is necessary.
Garbage collection is eliminated as a design issue.
Handling SQL is a non-issue for this stage of the project.
Thread safety is CRITICAL for this project
You will get no argument from me on this. This phase of the project needs to be tightly and cleanly written without the typical artifacts that get sucked into software including things like GUIs, business rules, web services and the other components of a full stack application. Ironically, your caveats cover points that lead me to think why Rust seems like such a good fit. This is expected to be a multi-year project. This piece of it is foundational, but as a matter of scale will be a very small piece of the entire system. It is very likely that much of the complete system will be written in other languages,
I will add this to my reading list. It looks interesting. When I learned C++ I leaned heavily on Bjarne Stroustrup's The C++ Programming Language so I appreciate this type of book. My monitor sits on a copy of Introduction To Algorithms by Cormen, Leiserson and Rivest (It's a first edition so it is sans Stein).
I love your idea of absorbing books by putting them under your monitor. I will dig out my copy of War and Peace immediately, though my monitor might then be too high.
Julie Sussman edited Cormen, Leiserson and Rivest just as she did Structure and Interpretation. Julie is an old friend and colleague (we worked together at BBN 40+ years ago) and she is the most amazing editor/quality-assurance person I have ever encountered.
I just want to point to https://explainshell.com/ , which is very helpful for command line newbies. It will help you to understand many things faster. People discussed rustup and Linux already, but the third aspect you mentioned (the command line) was mostly skipped, so I hope this hint has some value for you. Also, you may try the fish shell, which is extremely user friendly. Note though, that bash is a global default over nearly all distributions and therefore worth knowing. It is not very different from fish though. Fish has mostly a better autocomplete and stuff. It is my personal default.
I was in your situation 6 months ago. Except for the mesh invention part. I hadn't used Linux on a daily basis since my Uni days in 1996, and since then I've been using macOS at home, Windows at work. I've been an Apple Developer for the last 10ish years. I realised that working with container technology (and most other tech) required Linux for the optimum experience. Plus there were technologies I wanted to use that were simply unavailable on macOS.
I also realised I needed/wanted to develop a backend in Rust. I tried out a lot distros (usually in VirtualBox - Mint failed so badly there, I didn't even bother with it), but ultimately have settled on Fedora's KDE spin on bare metal. I've got it setup to mimic macOS down to the multi-touch gesture support. One thing I discovered is that, it's almost impossible to use Linux and not learn Linux at the same time. It will make you learn it. Having said that, Fedora is a breeze to use. You can install any downloaded .rpm file from the command line, or use their new-ish dnf command to install a package. It's as simple as dnf install rust. If you don't like the command line, simply use the GUI frontend dnfdragora. Avoid their Software Centre app. It's buggy, it crashes, and I don't even know why it exists, given that dnfdragora works so well. Fedora has that Red Hat pedigree. In 6 months, the only issue I've had is with a Linux kernel update that rendered my keyboard & touchpad useless, and that's easily worked-around by selecting the previous kernel when you boot. I'm dual-booting a MacBook Air however, so something like that may never happen.
I've had no problems installing and using Rust, via rustup and I use VSCode. For VSCode you can add their repo to your dnf and just get the updates are they are published, but I download the rpm on the website. The KDE desktop environment is also a lot more configurable than Mint/Ubuntu's GNOME.
Like you, I was also hoping for a lightweight setup. I even tried installing the default GNOME release, then installing just the KDE plasma desktop (without all the KDE apps), and then removing GNOME and it's apps, but you soon realise that you'll need a file manager, and an archive tool, and web browser, and on it goes. So the lightweight idea is nice, but it's best to just install a distro, live with it for a while, and then just nuke what you never use.
Weird things happen. After the initial research of what language to use, there was a considerable amount of time spent on working (months) out business considerations. The upshot is that a potential funding source for the project has materialized. The final decision on the programming language is mine and I am going with Rust.
I am not a gifted programmer, but I invented the tech described in our two patents so it's up to me to implement the core functionality. Worse, I haven't programmed anything in over 5 years and nothing substantial in 10. So I'm approaching this as a pseudo beginner.
I'm most of the way through The Book, using the text editor installed with Linux Mint.
Looks like I'll be hanging around this forum a lot. Rust is a fascinating language. I suspect I'll be asking a lot of questions.
Just as an aside, now that I'm seeing this thread again 8 months later, something stands out to me:
This actually sounds exactly like the kinds of problems that the actor model of computation was designed to deal with. Rust has nothing like this built directly into it, but knowing about it may still prove useful as it is more generally a conceptual framework for describing solutions to these kinds of problems.