Dedup IRnodes takehome!

[electriclilies]

The first approach I tried:

Attempt to identify all complex ir nodes by recursing through the whole ir tree.
Add these IR nodes to a list. Then use the multi_scope utility to try to eliminate
any duplicates all at once. I created an "inline_complex" method that does this.

The problem with this approach is that _optimize checks for duplicated symbols.
Unfortunately, to determine whether a node is complex, we have to call arg._optimized.is_complex_ir. This then fails since we have duplicated symbols (which we're attempting to get rid of). So it's a bit of a chicken and egg problem.

Also, we have to call the inline_complex method before optimize (again because of
the issue with optimize checking for duplicated symbols). We cannot call inline_complex
from within optimize because that would cause mutual recursion.

From here I see two potential approaches:

1. Try to get rid of duplicated symbols directly in the optimize method, but again we run into the mutual recursion problem here where to determine if a symbol is complex we have to run optimize on it.
2. Attempt to cache used IRnodes directly when we create them. I like this approach because it eliminates the need to deal with _optimize's fussiness about duplicated symbols / IRnodes-- we just won't allow duplicated IRnodes to be constructed in the first place. I decided to take this approach for my solution.

The second approach I tried is the approach that I am taking in this PR.
I create a class-level cache in IRnode that contains a mapping of the ids of IRnodes that we'd like to cache to the variable representing the IRnode.
Then, when constructing a new IRnode, check whether each argument's id is in the cache already. If it is, use the argument's unique id to look up the variable that corresponds to the IRnode, and replace the argument with it.
There are some cases where we don't want to attempt to cache the argument though, namely if the argument should be inlined, if the valency is not 1, or if arg.value is equal to "pass".
If the IRnode argument should be cached but isn't yet, we construct a new variable representing the IRnode and store it in the cache. We also add the new variable and the corresponding IRnode to a list so that we can properly define the variable in a "with" expression later.

Finally, I replace the current IRnode's args with the new, cached arguments. Additionally, I wrap the current IRnode in a "with" which defines the new variable that points to each cached arguments.

I think I currently have an issue with some cycles in the IRnodes, which is causing infinite recursion in the unique_symbols utility. I think that the way that I am updating the IRnode to include the "with" scoping is a bit sketchy and part of the problem, but I'm not exactly sure how to fix it.

Also, I did remove some cache_when_complex statements for testing purposes (specifically ones in arithmetic.py), but I think I accidentally removed them from the lib/python3.10/site-packages/vyper/ files, not from ones in the vyper repo, so they're not showing up in the PR.