Add small repro test for unsigned -> signed et loss error

Summary:
There was a difference in behavior from `quantized_decomposed.quantize_per_tensor`
and `cadence.quantize_per_tensor`, specifically how rounding half values worked.
The former rounds towards even (based on `torch.round` which does that).
The latter rounds away from zero.

Make sure the python implementation matches the Executorch implementation in this
regard.

Meta:
We found the cause of the et_loss issue in Eye Tracking Regressor which was caused
when switching the observer types: it led to off-by-one errors in between the
"quantized_decomposed" and "cadence" variants of the dq/q functions.

This small test repros the issue. To fix this, we change to use cadence quant functions
earlier in the pipeline (before turing ref-forward), and we change their python
implementation to more closely match the Executorch implementation with some
rounding tricks.

Differential Revision: D69668881

Author: dulinriley

backends/cadence/aot/TARGETS

@@ -180,6 +180,7 @@ python_library(
     typing = True,
     deps = [
         "//caffe2:torch",
+        ":ops_registrations",
         ":compiler_utils",
         "//executorch/backends/cadence/aot:pass_utils",
         "//executorch/backends/cadence/aot:utils",

backends/cadence/aot/fuse_ops.py

@@ -18,6 +18,8 @@
 
 import torch
 import torch.fx
+# Import these for the cadence function signatures.
+import executorch.backends.cadence.aot.ops_registrations # noqa: F401
 from executorch.backends.cadence.aot.compiler_utils import (
     broadcastable,
     get_cascaded_ops,

backends/cadence/aot/replace_ops.py

@@ -158,11 +158,12 @@ def call_operator(
         kwargs: Dict[str, Argument],
         meta: NodeMetadata,
     ) -> ProxyValue:
-        if op not in {exir_ops.edge.quantized_decomposed.quantize_per_tensor.default}:
+        ns = exir_ops.edge if isinstance(op, EdgeOpOverload) else torch.ops
+        if op != ns.quantized_decomposed.quantize_per_tensor.default:
             return super().call_operator(op, args, kwargs, meta)
 
         return super().call_operator(
-            exir_ops.edge.cadence.quantize_per_tensor.default,
+            ns.cadence.quantize_per_tensor.default,
             args,
             kwargs,
             meta,
@@ -184,11 +185,12 @@ def call_operator(
         kwargs: Dict[str, Argument],
         meta: NodeMetadata,
     ) -> ProxyValue:
-        if op not in {exir_ops.edge.quantized_decomposed.dequantize_per_tensor.default}:
+        ns = exir_ops.edge if isinstance(op, EdgeOpOverload) else torch.ops
+        if op != ns.quantized_decomposed.dequantize_per_tensor.default:
             return super().call_operator(op, args, kwargs, meta)
 
         return super().call_operator(
-            exir_ops.edge.cadence.dequantize_per_tensor.default,
+            ns.cadence.dequantize_per_tensor.default,
             args,
             kwargs,
             meta,