Refactor MainViewCB and Navigation.Item

Changes to MainViewCB
---------------------

This is a siginificant restructuring of the main controller in the
system and suggests a number of ideas and practices that should be
applied when refactoring the rest of the controllers or designing new
ones. UI code is inherently verbose; as such, the best we can do is to
structure a controller such as MainViewCB in a way that minimizes the
verbosity as much as possible and focuses on making what is happening as
clear as possible. That's why (as is described further below), almost
everything important now happens in the #initialize method. A major goal
of this change is that developers are able to look at MainViewCB and
read its #initialize method like a script. Indirections to other methods
are minimized as much as possible. The primary focus is on readability
(and therefore maintainability).

These changes began as an effort to substitute a mocked-out "backend",
i.e. bitcoin and p2p infrastructure, such that the application could
be run as quickly as possible, without the need for network
sychronization, bootstrapping, etc, for the purposes of UI development
and testing. Trying to make that change naturally evolved into this set
of refactorings. So at this point, MainViewCB is still "hard-wired" to
live bitcoin and tomp2p backends, but changing that, i.e. providing
mocked-out backends will be that much easier and clearer to accomplish
now.

Specifics:

 - Use public vs. private contstructor. This allows for the possibility
   of unit testing, avoids spurious warnings in the IDE, and generally
   adheres to the principle of least surprise.

 - Orchestrate creation and composition of components within the
   #initialize method. This avoids the need for member fields almost
   entirely.

 - Extract and delegate to private methods from #initialize only where
   it helps readibility. In general, this change assumes that initialize
   should be "where the action is": if the layout of a particular view
   is complex, then deal with that complexity directly within the
   #initialize method. However, if the creation of a given component is
   particularly verbose--for example the creation of the splash screen,
   then extract a #createSplashScreen method that returns a VBox. The
   same approach has been applied in extracting the
   #createBankAccountComboBox, #applyPendingTradesInfoIcon and
   #loadSelectedNavigation methods.

 - Extract the NavButton member class to cleanly encapsulate what it
   means to be a ToggleButton on the Bitsquare application navigation.
   This approach is similar to the MenuItem class in
   AccountSettingsViewCB.

 - Use "double-brace initialization" syntax for JavaFX components
   where appropriate, e.g.:

    HBox rightNavPane =
            new HBox(accountComboBox, settingsButton, accountButton) {{
        setSpacing(10);
        setRightAnchor(this, 10d);
        setTopAnchor(this, 0d);
    }};

   This approach, while typically rarely used, is an especially
   appropriate fit for JavaFX UI components, as the the allows for both
   maximum concision and clarity. Most JavaFX components are configured
   through a combination of constructor parameters and setter method
   invocations, and this approach allows all of them to happen at
   construction/initialization time.

 - Remove class section comments. In general--and as @mkarrer and I have
   discussed--these `////...` blocks shouldn't be necessary going
   forward. The goal is classes that are as small and focused as they
   can be, and they should be self-documenting to the greatest degree
   possible.

 - Remove empty lifecycle methods from the ViewCB superclass.

 - Remove Profiler statements. These are fine for specific debugging
   sessions, but should otherwise be removed for normal use.

Changes to Navigation.Item
--------------------------

These changes to the Navigation.Item enum were made in support of the
refactorings above, particularly in support of the newly extracted
NavButton class being as concise to construct as possible.

 - Introduce Navigation.Item#getDisplayName

   Push navigation button titles, such as "Overview" for HOME, "Buy BTC"
   for BUY, etc. into the Navigation.Item enum itself. This can later be
   refactored to support I18N, e.g. by embedding a message label instead
   of the actual english word. Not all Navigation items have a display
   name yet (and it may or may not make sense for them all to have one).
   The default value is "NONE".
Refactor ViewLoader for proper injection

ViewLoader is now modeled as a stateless singleton and injected into all
components (usually controllers) that need it. This is as opposed to the
prior situation in which a ViewLoader was instatiated every time view
loading was required. This was an understerstandable approach, given
that FXMLLoader (which ViewLoader wraps) assumes the same
construction-per-use approach, but it is nevertheless problematic.

 - Return Item tuple from ViewLoader#load.

   This avoids the need to call ViewLoader#load followed by individual
   calls to get the view and then the controller, as this requires
   mutable state to be held in the ViewLoader (which is now a shared
   singleton injected throughout the application). The previous approach
   is (a) confusing and (b) could create problems in a multithreaded
   environment. While (b) is unlikely in our case, the new approach is
   still clearer anyway.

 - Refactor ViewLoader#load to accept URL vs FxmlResource.

   This decouples the ViewLoader abstraction away from the
   Navigation.Item / FxmlResource abstraction completely.
Polish MainViewCB

Complete the MainViewCB refactoring process described earlier now that
ViewLoader is properly injected (see previous commit). Also, rearrange
the few private methods that remain to align with their order of
invocation.
Merge branch 'cbeams'

Changes made during the effort to decouple "backend initialization" for
the purpose of developing and testing the GUI while offline and/or
without having to actually connect to the bitcoin / tomp2p networks.
This decoupling is not yet possible--these changes just prepare for it.
These changes also represent the first steps in streamlining controller
archictecture toward maximum maintainability. See individual commit
comments for details.

* cbeams:
  Polish MainViewCB
  Refactor ViewLoader for proper injection
  Refactor MainViewCB and Navigation.Item