Game engines have to be especially efficient with these, in particular
inputs, for the sake of FPS loops. If anyone can provide
implementation details for inputs, that would suffice and be
appreciated.
In fact, receipt of the events you're talking about is generally nowhere near the bottleneck for a game. So we generally do not need to do anything particular clever or special or low-level to handle them. Generally, in fact, we just use whatever mechanism is provided for us on whatever platforms we're building for. This is fairly straightforward on Windows and macOS, which have standard GUI APIs that provide ways to listen for nearly all of the event types you listed.
For Linux, which does not have a hard standard GUI library, it's somewhat more complicated, but only by virtue of having potentially many APIs to choose from. One could directly write against Xlib, if one chose, although I'd venture to guess that most people would rather write against the APIs provided by Qt or GTK these days instead. The ease-of-use provided by the higher-level abstractions offered by the likes of Qt vastly overpower the insignificant "perf cost" of using such an abstraction, because (again) handling events is not a bottleneck for most games.
Certainly these days very games bother directly concerning themselves with IRQs or any other driver-level interrupt event. It's not worth the price of admission.
What is the efficient method I'm looking for? What is commonplace? If
I have to build it myself, where do you suggest I start? What tools
would I need?
Fundamentally you need to simply need to choose which GUI system you're going to use to build your game. SDL? Qt? GTK? There are many choices available and providing guidance as to which you should choose is out-of-scope for this site. They can all fulfill the basic task of giving you a window onto which you can paint your game graphics (with OpenGL or the like) and hook up the receipt of any sort of input event you might want.
Pick one that seems to work with your engineering style and go for it; this will cover most of your listed types of events (window-related ones and input-related ones). It's not necessarily true that a GUI API will also provide filesystem access APIs, but many do. If not you can simply pick an appropriate API according to your needs. For example if all you need is basic file IO, the C++ standard library will suffice. If you want something that leverages the OS's asynchronous file IO capability, you will need to use the OS's API or some wrapper around it. Similarly if you need filesystem-watch events (which isn't super common), you may need to use something like the inotify API.
