Implement usage of root inside changesSinceV2

Summary:
# Context

We are introducing EdenFS notifications to support scalable and ergonomic file system notifications for EdenFS mounts.

Watchman has a concept known as a relative root https://www.internalfb.com/intern/staticdocs/watchman/docs/file-query#relative-roots

This diff introduces the concept of a root to changesSinceV2.
A root is a path starting from the existing mount, from which all paths are computed against and acts as an overall include root, eg. all returned paths will start with the root, after which include/exclude roots will be computed, and paths outside the root will not be returned.
# This Diff

Implements root checking. Use the following flowchart for computing included/excluded roots.

```lang=mermaid
flowchart TD
    A[Has Root?] -->|No| B(No Change)
    A -->|Yes| C(Has included roots?)
    C-->|Yes| D(Root is prepended to included roots and excluded roots)
    C-->|No| E(Root becomes included root, and prependended to excluded roots, if any)
```

Use the following flowchart for determining how to handle outputs
```lang=mermaid
flowchart TD
    A[Has Root?] -->|No| B(No Change)
    A -->|Yes| C(Does change contain only one path)
    C-->|Yes| D(Root is stripped from output)
    C-->|No| E(Are both paths inside the root?)
    E-->|Yes| F(Strip root from both paths, return replace/rename)
    E-->|No| G(Is the change from outside the root into the root)
    G-->|Yes| H(Does the path already exist inside the root)
    G-->|No| I(Convert the change into Removed)
    H-->|Yes| J(Convert the change into Modified, from Replaced)
    H-->|No| K(Convert the change into Added, From Renamed)
```
Note that a directory rename is converted from a Large Change(DirectoryRenamed) into a Small Change(Directory Added/removed/modified)

# Technical Details

This diff adds some additional allocation overhead. This is to make the code more readable. If it becomes a performance issue, this can be optimized down the line.

The root matching is implemented by augmenting the includedRoots entries, as demonstrated in the flowchart above. The input included/excluded roots are appended to the root value.

# Discussion Points

Reviewed By: jdelliot

Differential Revision: D72603242

fbshipit-source-id: 60d3b54ffd0ad5472856b13bf3c8920f1801ac01

Author: Chris Dinh

eden/common/utils/PathFuncs.h

@@ -1504,6 +1504,30 @@ class RelativePathBase : public ComposedPathBase<
   bool isParentDirOf(const RelativePathPiece& other) const {
     return other.findParent(*this) != other.allPaths().end();
   }
+
+  /** Returns the substring of this path.
+   * If the new substring ends on a dir separator, remove that as well
+   * to satisfy RelativePathSanityCheck
+   *
+   * It is up to the caller to verify the position passed in, this function does
+   * not check if the path exists or not
+   *
+   * For example,
+   * calling substr() on "foo/bar/baz" will yield the following results:
+   * substr(0) => foo/bar/baz
+   * substr(20) => throws std::out_of_range exception
+   * substr(3) => bar/baz
+   * substr(4) => bar/baz
+   * substr(1) => oo/bar/baz
+   */
+  RelativePathPiece substr(size_t pos) const {
+    string_view substr_result = this->path_.substr(pos);
+    if (substr_result.size() > 0 && isDirSeparator(substr_result[0])) {
+      return RelativePathPiece{substr_result.substr(1)};
+    }
+    return RelativePathPiece{substr_result};
+  }
+
 }; // namespace detail
 
 /// Asserts that val is well formed absolute path

eden/common/utils/test/PathFuncsTest.cpp

@@ -1382,4 +1382,25 @@ TEST(PathFuncs, move_or_copy) {
   }
 }
 
+TEST(PathFuncs, substr) {
+  RelativePathPiece base{"root/bar/baz"};
+  RelativePathPiece root{"root"};
+  RelativePathPiece sub{"bar/baz"};
+  RelativePathPiece empty{""};
+
+  EXPECT_EQ(base.substr(0), base);
+  EXPECT_THROW(base.substr(20), std::out_of_range);
+  EXPECT_EQ(base.substr(root.view().size()), sub);
+  EXPECT_EQ(base.substr(root.view().size() + 1), sub);
+  EXPECT_EQ(base.substr(1), RelativePathPiece{"oot/bar/baz"});
+  EXPECT_EQ(base.substr(12), empty);
+  EXPECT_EQ(empty.substr(0), empty);
+
+  if (folly::kIsWindows) {
+    RelativePathPiece winBase{"root\\bar/baz"};
+    EXPECT_EQ(winBase.substr(root.view().size()), sub);
+    EXPECT_EQ(winBase.substr(root.view().size() + 1), sub);
+  }
+}
+
 } // namespace facebook::eden