text: Title: When should the `NapariApplication` be instantiated and its actions registered?
  Body: ## 🧰 Task
  
  ### When is `app` created?
  When we initialize a `napari.Viewer`, we must also instantiate the `NapariApplication` [object](https://github.com/napari/napari/blob/main/napari/_app_model/_app.py#L18) (which is our `app-model` app). The application is created when the `get_app` [class method](https://github.com/napari/napari/blob/main/napari/_app_model/_app.py#L40) is first called. 
  
  Currently, this first call happens during execution of the `intialize_plugins` [function](https://github.com/napari/napari/blob/main/napari/plugins/__init__.py#L25), which is called first thing on `Viewer.__init__` and [registers npe2 plugin actions](https://github.com/napari/napari/blob/main/napari/plugins/_npe2.py#L346). 
  
  Is it strange that the `NapariApplication`, which is so critical to the `Viewer` and its function, is created in this little function rather than explicitly before we register manifest actions etc.? It seemed to @lucyleeow and I that it was a little hidden and potentially could lead to issues? So wanted to open for discussion.
  
  ### When are `actions` registered?*
  
  \* I say actions here for brevity but these steps also include registering providers and processors.
  
  - [Internal non-qt actions](https://github.com/napari/napari/blob/main/napari/_app_model/_app.py#L35): as soon as we build the app, on `NapariApplication.__init__`. This seems normal to me.
  - [Internal qt actions](https://github.com/napari/napari/blob/main/napari/_qt/qt_main_window.py#L180): on `QtMainWindow.__init__`. Also seems normal to me I guess - not sure if there's meaning to moving it up or down in the function.
  - [Non-qt plugin actions](https://github.com/napari/napari/blob/main/napari/plugins/_npe2.py#L334): on `initialize_plugins` as above (which is up first on `Viewer.__init__`). This means it happens **after** internal non-qt actions and **before** internal/plugin qt actions. I think this is also ok.
  - [Qt plugin actions](https://github.com/napari/napari/blob/main/napari/plugins/_npe2.py#L335): immediately after non-qt plugin actions, if qt is available. This means it's **before** qt actions, providers and processors are registered with the viewer, even though some plugin actions (if executed) may request the `Viewer` provider. @lucyleeow and I thought maybe this was kinda weird, and we should potentially consider splitting this out so that qt plugin actions are only registered after `init_qactions`?
  
  Just a final note: in practice none of this seems to have caused any issues, and it may never. Everything is registered and available by the time the `Viewer` is returned. We just wanted to explicitly consider whether this is the right order of operations and whether there might be any potentially unintended consequences of the current setup down the line.