Implement fold_into_reduce and reassociate_expr

[SamirDroubi]

This PR implements two operations:

1. fold_into_reduce: folds an assignment into a reduction format
2. reassociate_expr: changes the associativity of addition and multiplication. This can be used to help with (1).

The primary reason behind this PR is being able to put assignments into reduction format which some analysis depends on (e.g. #557).

[codecov-commenter]

Codecov Report

Attention: 2 lines in your changes are missing coverage. Please review.

Comparison is base (fee83f5) 87.24% compared to head (d764e6e) 87.26%.

Files	Patch %	Lines
tests/test_schedules.py	94.73%	2 Missing ⚠️

❗ Your organization needs to install the Codecov GitHub app to enable full functionality.

Additional details and impacted files

@@            Coverage Diff             @@
##             main     #558      +/-   ##
==========================================
+ Coverage   87.24%   87.26%   +0.02%     
==========================================
  Files          82       82              
  Lines       19416    19487      +71     
==========================================
+ Hits        16939    17006      +67     
- Misses       2477     2481       +4     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[SamirDroubi]

I updated the name to left_reassociate_expr and changed the rewrite of fold_into_reduce to work on the lhs of the rhs of the assignment. I just still don't have a good name for it.

Some ideas:

• squash_into_reduce
• compound_assignment

[yamaguchi1024]

left_reassociate_expr looks good because it doesn't care about the content of A, B, and C as long as they are in this AST form:

I still think it's confusing for fold_into_reduce to accept the left figure while not accepting the right figure, even though they both look like a = a + b + ... in the frontend syntax.

[SamirDroubi]

They look the same because we simplify the parenthesis. My experience with languages that implements expression rewrites (like Coq) is that you just have to pay attention to these things when using the primitives. Then, you build hammer automations on top of it.

[yamaguchi1024]

I agree that we should build automation in the standard library, but at least the primitive definition should be consistent with what it is actually doing. The current documentation writes

    rewrite:
        a = a + ...
            ->
        a += ...

which doesn't accurately describe the acceptable program. You could change the documentation to describe the left figure above, but I think it will be hard to write the documentation with syntax that is opaque to users (binop AST).

[SamirDroubi]

We can change it to:

    rewrite:
        a = a + (...)
            ->
        a += ...

We also need to a better name that signifies what it does.

[yamaguchi1024]

Yeah I guess a = a + (...) is consistent. Also, folding reduction is necessary for circumventing the reorder_loop bug, right? So hopefully this won't be an issue when we have better analysis