Re-add unsafe compatability with unreleased root operators

From [@dariakp](https://github.com/dariakp):
> ... the reason we have RootFilterOperators extend Document is so that
> any driver version can be forwards compatible with new query operators
> that are continually being added to the server. There is an
> improvement that we would love to make to only extend $-prefixed keys
> instead of the generic Document (since operators are always
> $-prefixed), but we haven't had a chance to look into making that
> work.

Here we introduce such a type, but in a much more restricted format than
the `BSON.Document` type formerly extended:

- This is scoped explicitly to keys prefixed with `$`

- We can use the `unknown` type instead of `any`; in the event that a
  user is attempting to extract a value from an object typed as a
  `Filter<TSchema>` and use it somewhere they will be notified that it
  is not type safe and required to use a type cast or other workaround.

Follow-ups:
- Consider preferring safety of existing types over compatibility with
  with future operators (https://jira.mongodb.org/browse/NODE-3904)

Author: noahsilas

src/mongo_types.ts

@@ -91,8 +91,23 @@ export type AlternativeType<T> = T extends ReadonlyArray<infer U>
 /** @public */
 export type RegExpOrString<T> = T extends string ? BSONRegExp | RegExp | T : T;
 
+/**
+ * This is a type that allows any `$` prefixed keys and makes no assumptions
+ * about their value types. This stems from a design decision that newly added
+ * filter operators should be accepted without needing to upgrade this package.
+ *
+ * This has the unfortunate side effect of preventing type errors on unknown
+ * operator keys, so we should prefer not to extend this type whenever possible.
+ *
+ * @see https://github.com/mongodb/node-mongodb-native/pull/3115#issuecomment-1021303302
+ * @public
+ */
+export type OpenOperatorQuery = {
+  [key: `$${string}`]: unknown;
+};
+
 /** @public */
-export interface RootFilterOperators<TSchema> {
+export interface RootFilterOperators<TSchema> extends OpenOperatorQuery {
   $and?: Filter<TSchema>[];
   $nor?: Filter<TSchema>[];
   $or?: Filter<TSchema>[];

test/types/community/collection/filterQuery.test-d.ts

@@ -288,6 +288,9 @@ expectNotType<Filter<PetModel>>({ name: { $or: ['Spot', 'Bubbles'] } });
 /// it should not accept single objects for __$and, $or, $nor operator__ query
 expectNotType<Filter<PetModel>>({ $and: { name: 'Spot' } });
 
+/// it allows using unknown root operators with any value
+expectAssignable<Filter<PetModel>>({ $fakeOp: 123 });
+
 /**
  * test 'element' query operators
  */