[libcxx] Rename a method in PathParser for clarity. NFC.

[mstorsjo]

Summary

This was requested in the review of D91176.

libcxx/src/filesystem/operations.cpp

void increment() noexcept {
     switch (State) {
     case PS_BeforeBegin: {
       PosPtr TkEnd = consumeRootName(Start, End);
       if (TkEnd)
         return makeState(PS_InRootName, Start, TkEnd);
     }
       _LIBCPP_FALLTHROUGH();
     case PS_InRootName: {
-      PosPtr TkEnd = consumeSeparator(Start, End);
+      PosPtr TkEnd = consumeAllSeparators(Start, End);
       if (TkEnd)
         return makeState(PS_InRootDir, Start, TkEnd);
       else
         return makeState(PS_InFilenames, Start, consumeName(Start, End));
     }
     case PS_InRootDir:
       return makeState(PS_InFilenames, Start, consumeName(Start, End));
 
     case PS_InFilenames: {
-      PosPtr SepEnd = consumeSeparator(Start, End);
+      PosPtr SepEnd = consumeAllSeparators(Start, End);
       if (SepEnd != End) {
         PosPtr TkEnd = consumeName(SepEnd, End);
         if (TkEnd)
           return makeState(PS_InFilenames, SepEnd, TkEnd);
       }
       return makeState(PS_InTrailingSep, Start, SepEnd);
     }
 
void decrement() noexcept {
     const PosPtr REnd = getBeforeFront();
     const PosPtr RStart = getCurrentTokenStartPos() - 1;
     if (RStart == REnd) // we're decrementing the begin
       return makeState(PS_BeforeBegin);
 
     switch (State) {
     case PS_AtEnd: {
       // Try to consume a trailing separator or root directory first.
-      if (PosPtr SepEnd = consumeSeparator(RStart, REnd)) {
+      if (PosPtr SepEnd = consumeAllSeparators(RStart, REnd)) {
         if (SepEnd == REnd)
           return makeState(PS_InRootDir, Path.data(), RStart + 1);
         PosPtr TkStart = consumeRootName(SepEnd, REnd);
         if (TkStart == REnd)
           return makeState(PS_InRootDir, RStart, RStart + 1);
         return makeState(PS_InTrailingSep, SepEnd + 1, RStart + 1);
       } else {
         PosPtr TkStart = consumeRootName(RStart, REnd);
         if (TkStart == REnd)
           return makeState(PS_InRootName, TkStart + 1, RStart + 1);
         TkStart = consumeName(RStart, REnd);
         return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
       }
     }
     case PS_InTrailingSep:
       return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1,
                        RStart + 1);
     case PS_InFilenames: {
-      PosPtr SepEnd = consumeSeparator(RStart, REnd);
+      PosPtr SepEnd = consumeAllSeparators(RStart, REnd);
       if (SepEnd == REnd)
         return makeState(PS_InRootDir, Path.data(), RStart + 1);
       PosPtr TkStart = consumeRootName(SepEnd ? SepEnd : RStart, REnd);
       if (TkStart == REnd) {
         if (SepEnd)
           return makeState(PS_InRootDir, SepEnd + 1, RStart + 1);
         return makeState(PS_InRootName, TkStart + 1, RStart + 1);
       }
PosPtr getCurrentTokenStartPos() const noexcept {
     case PS_InTrailingSep:
       return &RawEntry.front();
     case PS_AtEnd:
       return &Path.back() + 1;
     }
     _LIBCPP_UNREACHABLE();
   }
 
-  PosPtr consumeSeparator(PosPtr P, PosPtr End) const noexcept {
+  // Consume all consecutive separators.
+  PosPtr consumeAllSeparators(PosPtr P, PosPtr End) const noexcept {
     if (P == nullptr || P == End || !isSeparator(*P))
       return nullptr;
     const int Inc = P < End ? 1 : -1;
     P += Inc;
     while (P != End && isSeparator(*P))
       P += Inc;
     return P;
   }
 
   // Consume exactly N separators, or return nullptr.
   PosPtr consumeNSeparators(PosPtr P, PosPtr End, int N) const noexcept {
-    PosPtr Ret = consumeSeparator(P, End);
+    PosPtr Ret = consumeAllSeparators(P, End);
     if (Ret == nullptr)
       return nullptr;
     if (P < End) {
       if (Ret == P + N)
         return Ret;
     } else {
       if (Ret == P - N)
         return Ret;