`OperatorNode` type should accept generics for 'op' and 'fn'

# The Problem

Right now all operator types share the same basic `OperatorNode` type. This has a few consequences:
- Nothing right now prevents creating invalid operators (like I did the other day) with `new OperatorNode('*', 'mult')`
- Right now you can't properly use multiple subsequent type guards that all check for a diff operator type

For example, say I've defined my own custom type guards like so

```ts
export function isAdditionNode(node: MathNode): node is OperatorNode {
return isOperatorNode(node) && node.fn === 'add'
}

export function isSubtractionNode(node: MathNode): node is OperatorNode {
return isOperatorNode(node) && node.fn === 'subtract'
}
```

If I try to then use them like this

```ts
function doStuff(node: MathNode) {
if (isAdditionNode(node)) {
return node.args[0]
}
if (isSubtractionNode(node)) {
return node.args[0]
}
}
```

Typescript is sad and upset because it thinks that the first type guard should have caught _any_ operator node and therefore you could never have the second case (explaining the `never` type)

# The Solution

If we added generic args to OperatorNode for `op` and `fn` typescript would warn us when making invalid operator nodes

and would allow doing this with type guards:

```ts
export function isAdditionNode(node: MathNode): node is OperatorNode<'+', 'add'> {
return isOperatorNode(node) && node.fn === 'add'
}

export function isSubtractionNode(node: MathNode): node is OperatorNode<'-', 'subtract'> {
return isOperatorNode(node) && node.fn === 'subtract'
}
```

Which then makes typescript very happy 🌈