This commit reverts a small part of
4ca923a34b.

This change fixes a bug where a fullscreen window would not receive
mouseMoved events until the cursor left and then reentered the
window's area.

This change fixes an issue where the touch keyboard failed to show when
selecting a TextEditor.

On the current versions of Windows 10 and 11, the undocumented
ITipInvocation workaround no longer seems to be required, so it has been
removed.

The isTabletModeActivatedForWindow function is no longer needed, and has
been removed. This function also appears to return inconsistent results:
the window may be in 'desktop mode', but devices with touchscreens
should still display the keyboard when selecting a TextEditor by touch.

Previously, individual components had to ask the peer to hide and show
the keyboard, by calling textInputRequired() and
dismissPendingTextInput() respectively. When an onscreen keyboard (OSK)
was required, most Peer implementation would directly hide/show the OSK
inside these function. However, the iOS ComponentPeer implementation
instead listened to the application's global keyboard focus, and only
opened the OSK when the focused component was also a TextInputTarget
with active input.

The iOS scheme seems like a better design, as it enforces that the OSK
hiding and showing is synced with the keyboard focus of the application.
In the other implementations, it was possible for a Component to call
textInputRequired even when it didn't have the keyboard focus, putting
the application into an inconsistent state. The iOS scheme also makes
the TextInputTarget interface more useful, as it enforces that the OSK
will only display for components that implement TextInputTarget, and
return true from isTextInputActive().

This patch changes all Peer implementations to match the iOS
implementation, improving consistency. Each time the global keyboard
focus changes, refreshTextInputTarget is called automatically, and the
OSK is shown if the focused component is a TextInputTarget that returns
true from isTextInputActive, and hidden otherwise. Components can also
call refreshTextInputTarget manually. This should be done whenever the
component updates the return value of isTextInputActive(). Effectively,
the Peer is now responsible for keeping track of the focused
TextInputTarget, rather than allowing individual components to hide and
show the OSK at will.

Additionally, this patch adds an option to the TextEditor to
automatically dismiss the OSK when the mouse is clicked outside of the
editor. This should improve user experience on mobile platforms, where
touches on sibling components may cause a TextEditor to gain keyboard
focus and unnecessarily display the OSK.

Until now when a Component without a parent was passed to setOwner() the
ParentVisibilityChangedListener would not install any hooks to any
components, hence it would not be notified, when the owner was added
to a parent.

Regions marked as dirty by repaint calls are now queued up and
dispatched when the corresponding physical display device is
refreshed

This change ensures that it is possible to put a plugin in an unprepared state
by calling releaseResources().

read() now returns failure in the case of a read timeout, or if
reading any block failed.

Changed the lifetime of the default MIDI oputput.
Removed the need for Timer workaround in AudioDeviceSelectorComponent.

This fixes an issue where Harrison XT-series plugin editors did not
update on mouse interaction in the AudioPluginHost.

This change reshuffles the way that parameter updates and notifications
work for hosted VST3 plugins.

Previously:
- Parameter::setValue would update the processor and editor, but not the
  host
- Parameter::setValueFromEditor would update the processor and host, but
  not the editor
- MIDI CC events would be converted to events and added to the
  processor's input event list, but were not forwarded to the
  IEditController.

Now:
- Parameter::setValue updates the host's cachedParamValues, which is the
  host's source of truth for parameter values. On each process callback,
  changes will be added to the input parameter list. Then, for each item
  in the parameter list, an update will be dispatched back to the
  editor.
- Parameter::setValueFromEditor is removed. All parameter changes will
  be sent back to the editor, even if they originated from the editor.
  setValueNotifyingHost can be used to notify listeners that one of the
  host's JUCE parameters has changed, e.g. in the host context's
  performEdit.
- MIDI CC events trigger calls to setValueNotifyingHost on any mapped
  parameters. The flow is very similar to a parameter change from the
  editor: the cachedParamValues are updated immediately, and host
  parameter listeners are notified. Then, for each changed
  cachedParamValue an entry is added to the inputParameterChanges
  (updating the processor), then for each item in the
  inputParameterChanges an update is sent to the editor.

This includes Carbon support