Search refactor predecessors: ImmutableStack, Option, More Extensions

@ikeough @lukechurch As discussed in https://github.com/DynamoDS/Dynamo/pull/3463
Convenience class for representing a piece of data that can be 1 of 2 possible types. It's required for the `GroupByRecursive` extensions.

Given a category:
```
ACategory
|
+-B.Child1
+-B.Child2
+-C.Child1
+-D.Child1
...
+-Child1
+-Child2
```
and it's time to categorize its leaves, we can categorize them into sub-categories, which yields a grouping from (subCategoryName => subCategoryContents). 
```
ACategory
|
+-B
| |
| +-Child1
| +-Child2
|
+-C
| |
| +-Child1
|
+-D
| |
| +-Child1
...
|
+-Child1
+-Child2
```

However, there's also the possibility that there are leaves that aren't in a sub-category, but rather belong on the current category (see the bottom of the diagram above).

Let the type of a category be `IGrouping<string, ICategory>` (`IGrouping` is included with .NET). This can be read as _a category is a collection of sub-categories with a key of type `string`_. Of course, sub categories are no different from regular categories, and so we can represent the recursive relationship in the following type declaration: `ICategory<string> : IGrouping<string, ICategory<string>>`.

This is a good start, but there's a problem: how do we get to the leaves? The leaves do not have type `ICategory<string>`, and so cannot be a part of the recursive enumerable sequence. Where can they be added?

The way I opted to solve this was to represent the grouping "key" as an `IEither<string, IEnumerable<IChild>>`. That is to say, given a grouping, it's either a sub category (indicated by the presence of a category name as the key), or it's a sequence of the leaves. This makes the actual signature for a category: `IRecursiveGrouping<IEither<string, IEnumerable<ILeaf>>>`

-----

This is used internally so that Linq's `GroupBy` method could be leveraged to perform the grouping. In most of the user-facing `GroupByRecursive` extensions, the return type derived above is converted to a more conventional tree-like API.