Integrating a new platform is never easy. depends on Python or anything else is just passing the hard work to someone else. If Rust have the exhibition to be in the position C currently have, it should be ready to bootstrap itself without anything else (well, this is not true in all sense. To build gcc toolchain you need build-essentials including Make, awk etc, but all those was written in C itself), because this is what C currently can do.
It is not necessary to have network connection for building rustc. What we have to do is
limiting the referencing crates that the rustc source code can refer to
allowing rustup to be embedded in distributions with selected crates
then we can build rustc without require anything else. This is similar to build-essentials in Debian. we could have rust-essentials!
Making rustc easier to port/build is an important goal, but the dependencies highlighted here (Python and CMake) don't seem like the best aspects to focus on.
The Python dependency neither makes it significantly harder for people to build rustc on supported platforms, nor does it pose a particular porting challenge:
Python is ubiquitous. It is almost certainly already be present on any Unix-ish computer. It's not not quite so ubiquitous on Windows (at least outside of mingw environments), but it's still quite a standard tool, and there are high quality binary distributions for Windows.
Python is required for LLVM's test suite anyway. Rust doesn't run the tests, but it does mean that porting Python is already practically required for porting LLVM to another platform, and porting LLVM is a prerequisite for porting rustc.
I've never heard of any C++ project vendoring CMake. Why is Rust different? Why is it okay to require the user to have a modern C++ compiler needed by LLVM, but requiring them to have CMake (a prerequisite for many C++ projects) is too much?
I also have questions about this proposed automatic installation: Which version do we install, and how do we make sure we're not missing important distro-specific patches? If there's no official binary distribution for the host platform, do we fetch the source and built it ourselves? How do we handle dependencies CMake itself may have? And finally, how do we justify the implementation and maintenance effort? (Besides the initial implementation, there's bound to be a long tail of bugs where this convenience functionality doesn't work as expected on odd systems.)
There the run-make test suite. There's plans to remove the Make dependency there, which would make it easier to run the full test suite on Windows. (Make is far harder to get than Python, short of installing a full mingw environment, and last time I did that building Rust in it had other draw backs.)