Reading it again this morning, I found it a bit confusing until I had a good look through again, referring to the code. Is it ok to push a change with the whole Page and Three-in-one sections rewritten as follows? We can still tweak/refine of course.
    
    Page
    ~~~~
    
    The SimpleCMSBundle basic content type is ``Page``. Its class declaration
    points out many of the features available:
    
    * It extends ``Route``, meaning it's not only a ``Content`` instance, but
      also a ``Route``.
    * It implements ``RouteAwareInterface``, which means it has associated
      ``Route`` instances. As we will explain shortly, the associated ``Route``
      is actually the ``Page`` instance itself.
    * It implements ``NodeInterface``, which means it can be used by
      ``MenuBundle`` to generate a menu structure.
    
    The class itself is similar to ``StaticContent`` already described in the
    documentation page regarding :doc:`content`. However some key attributes,
    such as ``parent`` or ``path``, come from the ``Route`` class it extends.

    Three-in-one
    ~~~~~~~~~~~~
    
    As explained above, this bundle gathers functionality from three distinct
    bundles: :doc:`content`, :doc:`routing` and :doc:`menu`. The roles of a
    content document, route and menu item are all fulfilled by the ``Page``
    class.
    
    In other words, an instance of ``Page`` can represent persistent content
    through use of the PHPCR-ODM annotations, and slot into the publishing
    work flow by implementing ``PublishWorkflowInterface``.
    
    Furthermore, the same ``Page`` can *have* an associated route, because
    it implements ``RouteAwareInterface``, but it can also *be* that
    route, because it extends ``Route``. Finally, the ``Page`` instance can
    also drop into place within a menu hierarchy because it implements
    ``NodeInterface``.
    
    Here's how that works in practice:
    
    * The routing component receives a request that it matches to a ``Route``
    instance loaded from persistent storage. That ``Route`` points to a
    ``Page`` instance.
    
    * Which controller to use is determined by the routing component that renders
    the ``Page``, using a template to output the content (usually in HTML).
    
    * The controller also renders the stored information tree structure
    using ``MenuItem``, obtained from equivalent ``NodeInterface`` instances.
    
    This three-in-one approach is the key concept behind the bundle.