Move PathName to its own module

And make it usable in its own right.  Specifically, it is now a Monoid
again and users can construct pathnames with the public API without
going through Path or Reify.  This all means that PathName now is much
less safe than before, which in turn means that reifying a path throws
away much of the safety since we can't distinguish between a safely
reified PathName and an unsafely user-created PathName.  However, the
plan is to change Reify to return an opaque newtype around PathName,
which will also have the invariant that it's always canonicalized.

So then, what is the point of PathName?  Well, it simplifies the
implementation of Path and Reify by moving a lot of the #ifdefs out,
and, some users might prefer a less safe but more practical and familiar
API that still supports mixed-encoding paths and an efficient
representation on supported platforms.

In the future, PathName might even be moved to its own package,
implementing the API directly with bytestrings using unix/Win32 instead
of just wrapping posix-paths or filepath/directory.  However, that might
not be feasible without support for ByteString APIs in the Win32
package.
Test both non-POSIX and Windows, always

The __WINDOWS__ #define doesn't currently load any code that *requires*
Windows, or the Win32 package, so this works for now.  If it becomes a
problem in the future, we can always introduce a __TEST__ #define or
somesuch.
Get rid of render and all its support code

We can use System.PathName.build instead.  We lose some functionality
such as rendering unresolved paths, or rendering to a foreign
representation, but those features were only internal and unused anyway
and wouldn't be difficult to restore.

In theory, this might also have worse performance due to joinPath not
using bytestring's optimized concat, but if that is the case it's an
easy fix to make it use intercalate.  Perhaps by patching posix-paths
upstream.

This may or may not be possible without throwing away either the gain in
performance or the monoidal semantics of combine.  It may also turn out
to be an unnecessary manual optimization that the compiler already does,
in some way.

Consequently, System.Path.Internal is significantly simplified and
almost completely #ifdef free.  Almost.
Introduce opaque RealPath for canonicalized paths

And repurpose Resolve as a variant of Reify that produces these
canonicalized absolute pathnames instead.
PathName internals cleanup
Big rewrite of Reify/Resolve/RealPath
Remove outdated documentation