Constant-folding on intermediate language

[Sword-Smith]

Constant folding in the intermediate language should reduce expressions such as BFieldElement::new(100) * BFieldElement::new(100) to BFieldElement::new(10_000).

The compiler will parse and graft let a: BFieldElement = BFieldElement::new(100) * BFieldElement::new(100); to this intermediate expression:

Let(
            LetStmt {
                var_name: "a",
                mutable: false,
                data_type: BFE,
                expr: Binop(
                    Lit(
                        BFE(
                            BFieldElement(
                                429496729500,
                            ),
                        ),
                    ),
                    Mul,
                    Lit(
                        BFE(
                            BFieldElement(
                                429496729500,
                            ),
                        ),
                    ),
                    KnownType(
                        BFE,
                    ),
                ),
            },
        ),

After the constant folding the BinOp of type Mul should be removed and only one BFE element should remain.

Constant folding on the intermediate language should be handled for these data types:

• [ ] bool, simplifying e.g. !!a to a
• [ ] BFieldElement (internally called BFE)
• [ ] XFieldElement (internally called XFE)
• [ ] u32 simplifying e.g. 14u32 + 15u32 to 29u32
• [ ] u64
• [ ] u128