GeezerVison

Introduce stub classes with initial tests on what will become
subclassable alternatives to PurePath/Path that do not have
inverted dependencies.

Replace references in PurePath and changed function in
_BasePurePathTest.test_ordering_common to test missing execution paths.
This is preparation for seperating the base class and factory
functionality in PurePath in order to fully implement SimplePath.

Introduce new base class _PurePathBase and move all of the methods
from PurePath into it (except for the factory __new__) for use in
building SimplePath / FilePath.

SimplePath provides a subclassable alternative to PurePath which is
otherwise functionally equivalent -- passing all of the existing
PurePath tests.

Partial implementation of FilePath which offers all of the PurePath
and SimplePath functionality and passes the equivalent existing tests.

Existing is_mount method in Path was Posix only and not cross
platform even though it was in a cross-platform base class. The existing
design relied upon being overriden later in WindowsPath. Consolidated
code from both into new Path.is_mount() which is now cross plaform
similiar to all of the other Path methods.

Replace hardcorded references to pathlib.Path so that the base
class and factory functionality of Path can be seperated.

FilePath provides a subclassable alternative to Path which is
otherwise functionally equivalent -- passing all of the existing
Path tests.

SimplePosixPath and SimpleWindowsPath provide a subclassable
alternative to PurePosixPath and PureWindowsPath which are otherwise
functionally equivalent -- passing all of the existing PurePosixPath
and PureWindowsPath tests.

Fix _BasePurePath comparison operators so that all of the new
path classes in pathlib are comparable with one another and return
results that are consistent with the existing behavoir, i.e.
Path('/') == PurePath('/').

Document and make public FilePath, SimplePath, SimplePosixPath,
SimpleWindowsPath, and PathIOMixin. Also add section to pathlib
documentation regarding the limitations of PurePath and Path with
regards to subclassing and how to use these new classes as alternatives.