optimized implementation of pathlib #194

These noteworthy internal methods are called when path objects are constructed:

• pathlib.PurePath._split_root() is ripe for optimization - it calls splitdrive() twice, and uses normpath() to normalize anchors. As @eryksun points out, this could be done by adding an os.path.splitroot() function, implemented separately in ntpath and posixpath, and called by pathlib. The OS-specific implementations can be tuned more readily than the OS-agnostic implementation in pathlib.
• pathlib.PurePath._parse_parts() may benefit from line-by-line tuning, e.g. assigning cls._flavour up-front to a local variable.
• pathlib.PurePath._parse_args() is probably unnecessary since #95450 landed. Removing it may improve performance (needs testing).

this could be done by adding an os.path.splitroot() function

The split functions in os.path are conservative, but _split_root() isn't always conservative. On Windows, it splits an implicit root from a UNC share. For example, it splits "\\server\share" as ('\\\\server\\share', '\\', ''). I think this is okay as long as it's documented.

Also, the implementation should be fixed to handle device paths correctly on Windows. For example, a volume device path such as "\\.\C:" has no root, but _split_root() handles it incorrectly as if it's "\\.\C:\". If this gets fixed, then is_absolute() needs to be updated to return true for all UNC paths. For example, return bool(self._drv and (self._root or self._drv[0] == '\\')).

The PurePath constructor does roughly these expensive things:

1. Joins the arguments together to a single unnormalized string
2. Splits the string into (drv, root, parts), normalizing the root and the parts.

Both of these operations are necessary in some cases, e.g. for __str__, __hash__, __eq__ and others.

However, in some cases, step (2) is probably unnecessary. This includes the majority of Path methods, where the OS should treat the unnormalized path the same as the normalized one.

And in some further cases, both are unnecessary. Importantly this includes __truediv__() and joinpath().

If these steps were performed on-demand, rather than at the time of path construction, I think we could dramatically improve pathlib performance for some common cases.

Here's a PR that makes pathlib defer path normalization until it's strictly needed: python/cpython#101560

As I mentioned in my previous comment, path normalization is not needed in __fspath__() (and consequently, many Path methods), nor in construction / joining. It is needed for walking directories and many PurePath methods. The former bunch get up to 4x faster, the latter lot get up to 25% slower.