Web: Implement MonitorHandle

[daxpedda]

This is based on and requires #3805.

This implements MonitorHandle on Web by using the Window Management API, which is currently only implemented on Chrome.

This gets a bit complicated, because to access the API the user has to explicitly be asked to give permission, on top of most calls being asynchronous. So to solve this I implemented a couple of things:

• When the EventLoop is created, the browser is queried, in the background if the user has previously given permission to use the Window Management API.
• When the event loop is started, EventLoop::run(), it is delayed until this asynchronous query has finished. Which should really only be one tick.
• If the user has previously given permission to use the Window Management API, we can use it.
• If not, we fallback to Window.screen, which is implemented on all browsers. The "downside" is that it contains much less information about the current monitor and no information about primary or other monitors.

Cool things:

• At none of these steps the user is actually asked to give permission. To explicitly ask the user for permission, ActiveEventLoop::request_detailed_monitor_permission() has to be used.
• None of the Futures have to polled to completion, dropping them is fine. They are only there to receive errors or allow the user to "know when something has finished doing its thing".
• MonitorHandles created with the Window Management API can be targeted with Window::set_fullscreen().
• If the user somehow grants the site permission to use the Window Management API externally without going through Winit, we detect this and automatically upgrade the backend.
• Everything that can be cached is cached to minimize any JS FFI calls. E.g. multiple calls to ActiveEventLoop::request_detailed_monitor_permission() do nothing, instead they share the result to minimize any JS overhead.

Not cool things:

• There is no way to "upgrade" MonitorHandles to use the new API if they were created using the fallback.
• VideoModeHandle is basically useless, its only there to expose bit_depth().
• Using MonitorHandle with Window::set_fullscreen() only makes sense if it was created using the Window Management API, otherwise it doesn't work.
• Currently the only way for users to receive errors is to pull the returned Futures to completion.
• The whole screen orientation API has no cross-platform implementation, so its all implemented via extension traits.

---

Follow-up:

• Add stuff to Browser support tracking #2875.
• Return Option from MonitorHandle::scale_factor().
• Return Option from MonitorHandle::position().
• Rename Window::set_fullscreen() to Window::request_fullscreen() and maybe return an error. If not introduce an Web-only async version of it to allow users to actually handle failure.
• Add current bit_depth() to MonitorHandle and remove VideoModeHandle from Web again. (Add MonitorHandle::current_video_mode() #3802)
• Open tracking issue for cross-platform monitor events.
• Open tracking issue for cross-platform screen orientation getters, locking and events.

[daxpedda]

I extracted some unrelated changes to #3805 and based this PR on it.

[daxpedda]

No changes so far, only rebasing on all the churn.

[kchibisov]

Generally Eq/Ord go after their Partial impls.

[daxpedda]

I generally do this alphabetically in the Web backend.
So I would like to stick to that.

I can make a follow-up PR where I align all derives and implementations in the whole crate to do PartialEq/PartialOrd before Eq/Ord and generally have the same order throughout the crate if you like.

[kchibisov]

I'd just suggest to do that for the new stuff since it's just pointless, unless we have a formatter support.

I won't block on the current order either, just noticed that it's usually other way around (you can also derive(Eq) if you have impl PartialEq).

[daxpedda]

No unfortunately no formatter support ...
I will make a PR only for Web then, because Web follows alphabetical order so far.

[kchibisov]

• already present comments about nesting, since the code is really hard to follow...