Straight out of Uni in 2001, I became an operating systems programmer bringing up a new platform and pretty much immediately started debugging C++ code almost exclusively in an asm debugger (it's what we had for an OS level debugger). I also started implementing capabilities provided by a hypervisor directly available via asm instruction because there wasn't a C construct for doing so).
After that I became a toolchain programmer (working mostly on new system libraries) and would write in C and Assembly language and debug mostly in Assembly language because, when you're working on system libraries and the toolchain for a new platform, you can't always trust the compiler, and the compiler can't always generate optimal code (or any code) based on the new instruction set. Oh, and you can't always trust the debugger either if it doesn't understand the instruction set.
While there I would work on 9 new platform bringups and would often need to stub in assembly language routines for capabilities that were in the architecture but not yet available in the toolchain. Other times, new system call routines, locking intrinsics, unwinders, exception handlers, and some optimized routines would require implementation in asm as well.
If you're only working on the non-platform part of an operating system, you might not need to learn assembly language, but if you touch platform code you will likely need to know it.
Compared to twenty years ago, there are significantly fewer operating systems which means fewer companies have a need for this type of work. If you're looking to get into this work I'd suggest looking at Apple, Samsung, Nvidia, Qualcomm, Google, Microsoft, Arm, and any Arm architecture licensee. It seems that the people with the most luck these days end up tinkering with Linux at university, do a Google Summer of Code project and score an internship with one of the above.
But those were systems where we abstracted away as much of the hardware as we could so everyone could focus on "business logic." The hardware interface is the part that's hardest to debug, so we try to put as little as possible into those layers.
Unfortunately, it sounds like that's exactly where you want to be working :-(
I've been programming embedded systems for the majority of my career and if you were to tell me that you just learned assembly, I'd wonder why you were wasting time like that. The last time I did more than glance at assembly language would have been around 1999.
If it's for a hobby, grab an arduino clone board and go for it! I'd suggest something ESP32-based though.