Remove verify from OperationBuilder and SameOperandsAndResultType verification implementation

[lima-limon-inc]

Closes # issue nm

The issue states that currently Operation::verify is called inside the OperationBuilder which is called before operations are added to blocks, which could lead failure in operation verification. Because of this, SameTypeOperands' verification function had been commented out.

This PR removes the call to Operation::verify from the OperationBuilder and moves it to the beggining of PassManager::run. Operation::verify is already called inside the PassManager::run (more precisely, inside the OpToOpPassAdaptor::run_pipeline), however an earlier verify call was added to "compensate" the removal and assure Operation integrity before applying passes. Now, the PassManger is responsible for Operation integrity verification, which is done before passes are applied and after each pass applies its modifications.

With the call to verify in the OperationBuilder now removed, SameTypeOperands' verification function was re-enabled and so was its test (derived_op_verifier_test).

Additionally, an implementation for SameOperandsAndResultType's verification function was added (which was marked here as a TODO-item). Following the comment's requirements, SameTypeOperands required as a super-trait.

To support this, the derive! macro was expanded to support super-traits. The macro supports an arbitrary amount of traits; but it is important to note that the traits must be comma separated instead of the usual "+" separated format. As far as I am aware, it is not possible to use "+" as a separator inside a macro_rules! context.

With the super-trait now added, operations that implemented SameOperandsAndResultType but did not implement SameTypeOperands were updated to now explicitely implement both. This was done explicitely in order to replicate Rust's #[derive] macro's behavior of explicitely declaring all derive traits.

Finally, a unit test was added to test SameOperandsAndResultType's verify function. For this, a test operation InvalidOpsWithReturn was added and registered in the test dialect.

Side note: I tried to keep the SameOperandsAndResultType's doc comment relatively short in order for it to show up in its entirety when a compilation error shows up, it is currently displayed like so:

72  | / derive! {
73  | |     /// Op expects all operands and results to be of the same type.
74  | |     /// NOTE: Operations that implements this trait must also explicitely implement
75  | |     /// [`SameTypeOperands`]. This can be achieved by using the "traits" filed in the [#operation]
...   |
87  | |     pub trait SameOperandsAndResultType: SameTypeOperands {}
    | |               ------------------------- required by a bound in this trait

[lima-limon-inc]

Just Rebased

[igamigo]

nit: filed -> field

[lima-limon-inc]

Oh, my bad! Great catch

[igamigo]

Would be great if this were an enum instead of a bool but it was there from before so it should be fine to leave it as-is.

[igamigo]

nit: Should this be something more like the following:

Suggested change

	"which differs from this value"
	"which differs from this value's type"

[lima-limon-inc]

Fair point!. I tried to replicate the structure/text present in the original verifier here: https://github.com/0xMiden/compiler/blob/f0ff05aca81e9dc579899223d2f19bb7200fbffd/hir/src/ir/traits/types.rs#L40-L61.

But I do think that it is clearer with your suggestion.