Do not merge this until/unless #1455 is merged; this PR is based off that branch, and will be rebased as necessary, as that PR significantly decreases startup times in certain circumstances.

Exploratory.

We've had a number of issues over the years with our current system of reloading. Normally, when you reload a module, it works, sometimes. But sometimes it doesn't; depending on exactly what's being reloaded, and where.

This causes all sorts of problems with inconsistent behaviour across restarting vs. reloading.

The solution we've talked about in the past was simply doing away with reloading, and focusing on restarting. This has a number of advantages.

1. It allows for consistent behaviour across the board, with no distinctions between reloading and restarting.
2. Certain things, which couldn't be done before (properly re-overloading functions) are now done efficiently and correctly at all times; the current model of override never really worked with the reload system.
3. It removes a large chunk of code that deals with this dichotomy and simplifies the system greatly.
4. It forces a high-quality reload experience, since we're no longer jumping between reloads and restarts; for things to be submitted and work, they must restart correctly, which should've always been the case anyway.
5. It eliminates bugs from modules that don't ever expect to be reloaded and aren't coded for it.

It also has a disadvantage or two:

1. In theory, plugins that have long running processes have no way of persisting between restarts easily without calling detach.
2. Plugins that have slow-startup times will be unnecessarily reloaded, and could slow things down on a restart.

IMO, the advantages by far and away outweigh the disadvantages. This PR is going to focus on making sure it all works, while proposing enhancements to restarting, so that it's as seamless and smooth as possible. WIP.