Use the common OperatorPrecedence for the parser (#16747)

## Summary

This change continues to resolve #16071 (and continues the work started
in #16162). Specifically, this PR changes the code in the parser so that
it uses the `OperatorPrecedence` struct from `ruff_python_ast` instead
of its own version. This is part of an effort to get rid of the
redundant definitions of `OperatorPrecedence` throughout the codebase.

Note that this PR only makes this change for `ruff_python_parser` -- we
still want to make a similar change for the formatter (namely the
`OperatorPrecedence` defined in the expression part of the formatter,
the pattern one is different). I separated the work to keep the PRs
small and easily reviewable.

## Test Plan

Because this is an internal change, I didn't add any additional tests.
Existing tests do pass.

crates/ruff_python_ast/src/operator_precedence.rs

@@ -131,6 +131,12 @@ impl OperatorPrecedence {
     pub fn from_expr(expr: &Expr) -> Self {
         Self::from(&ExprRef::from(expr))
     }
+
+    /// Returns `true` if the precedence is right-associative i.e., the operations are evaluated
+    /// from right to left.
+    pub fn is_right_associative(self) -> bool {
+        matches!(self, OperatorPrecedence::Exponent)
+    }
 }
 
 impl From<&Expr> for OperatorPrecedence {
@@ -177,3 +183,12 @@ impl From<BoolOp> for OperatorPrecedence {
         }
     }
 }
+
+impl From<UnaryOp> for OperatorPrecedence {
+    fn from(unary_op: UnaryOp) -> Self {
+        match unary_op {
+            UnaryOp::UAdd | UnaryOp::USub | UnaryOp::Invert => Self::PosNegBitNot,
+            UnaryOp::Not => Self::Not,
+        }
+    }
+}