Introduce LiteralExpressionRef for all literals (#8339)

## Summary

This PR adds a new `LiteralExpressionRef` which wraps all of the literal
expression nodes in a single enum. This allows for a narrow type when
working exclusively with a literal node. Additionally, it also
implements a `Expr::as_literal_expr` method to return the new enum if
the expression is indeed a literal one.

A few rules have been updated to account for the new enum:
1. `redundant_literal_union`
2. `if_else_block_instead_of_dict_lookup`
3. `magic_value_comparison`

To account for the change in (2), a new `ComparableLiteral` has been
added which can be constructed from the new enum
(`ComparableLiteral::from(<LiteralExpressionRef>)`).

### Open Questions

1. The new `ComparableLiteral` can be exclusively used via the
`LiteralExpressionRef` enum. Should we remove all of the literal
variants from `ComparableExpr` and instead have a single
`ComparableExpr::Literal(ComparableLiteral)` variant instead?

## Test Plan

`cargo test`

crates/ruff_python_ast/src/expression.rs

@@ -336,3 +336,28 @@ impl Ranged for ExpressionRef<'_> {
         }
     }
 }
+
+/// Unowned pendant to all the literal variants of [`ast::Expr`] that stores a
+/// reference instead of an owned value.
+#[derive(Copy, Clone, Debug, PartialEq, is_macro::Is)]
+pub enum LiteralExpressionRef<'a> {
+    StringLiteral(&'a ast::ExprStringLiteral),
+    BytesLiteral(&'a ast::ExprBytesLiteral),
+    NumberLiteral(&'a ast::ExprNumberLiteral),
+    BooleanLiteral(&'a ast::ExprBooleanLiteral),
+    NoneLiteral(&'a ast::ExprNoneLiteral),
+    EllipsisLiteral(&'a ast::ExprEllipsisLiteral),
+}
+
+impl Ranged for LiteralExpressionRef<'_> {
+    fn range(&self) -> TextRange {
+        match self {
+            LiteralExpressionRef::StringLiteral(expression) => expression.range(),
+            LiteralExpressionRef::BytesLiteral(expression) => expression.range(),
+            LiteralExpressionRef::NumberLiteral(expression) => expression.range(),
+            LiteralExpressionRef::BooleanLiteral(expression) => expression.range(),
+            LiteralExpressionRef::NoneLiteral(expression) => expression.range(),
+            LiteralExpressionRef::EllipsisLiteral(expression) => expression.range(),
+        }
+    }
+}