Split Constant to individual literal nodes (#8064)

## Summary

This PR splits the `Constant` enum as individual literal nodes. It
introduces the following new nodes for each variant:
* `ExprStringLiteral`
* `ExprBytesLiteral`
* `ExprNumberLiteral`
* `ExprBooleanLiteral`
* `ExprNoneLiteral`
* `ExprEllipsisLiteral`

The main motivation behind this refactor is to introduce the new AST
node for implicit string concatenation in the coming PR. The elements of
that node will be either a string literal, bytes literal or a f-string
which can be implemented using an enum. This means that a string or
bytes literal cannot be represented by `Constant::Str` /
`Constant::Bytes` which creates an inconsistency.

This PR avoids that inconsistency by splitting the constant nodes into
it's own literal nodes, literal being the more appropriate naming
convention from a static analysis tool perspective.

This also makes working with literals in the linter and formatter much
more ergonomic like, for example, if one would want to check if this is
a string literal, it can be done easily using
`Expr::is_string_literal_expr` or matching against `Expr::StringLiteral`
as oppose to matching against the `ExprConstant` and enum `Constant`. A
few AST helper methods can be simplified as well which will be done in a
follow-up PR.

This introduces a new `Expr::is_literal_expr` method which is the same
as `Expr::is_constant_expr`. There are also intermediary changes related
to implicit string concatenation which are quiet less. This is done so
as to avoid having a huge PR which this already is.

## Test Plan

1. Verify and update all of the existing snapshots (parser, visitor)
2. Verify that the ecosystem check output remains **unchanged** for both
the linter and formatter

### Formatter ecosystem check

#### `main`

| project | similarity index | total files | changed files |

|----------------|------------------:|------------------:|------------------:|
| cpython | 0.75803 | 1799 | 1647 |
| django | 0.99983 | 2772 | 34 |
| home-assistant | 0.99953 | 10596 | 186 |
| poetry | 0.99891 | 317 | 17 |
| transformers | 0.99966 | 2657 | 330 |
| twine | 1.00000 | 33 | 0 |
| typeshed | 0.99978 | 3669 | 20 |
| warehouse | 0.99977 | 654 | 13 |
| zulip | 0.99970 | 1459 | 22 |

#### `dhruv/constant-to-literal`

| project | similarity index | total files | changed files |

|----------------|------------------:|------------------:|------------------:|
| cpython | 0.75803 | 1799 | 1647 |
| django | 0.99983 | 2772 | 34 |
| home-assistant | 0.99953 | 10596 | 186 |
| poetry | 0.99891 | 317 | 17 |
| transformers | 0.99966 | 2657 | 330 |
| twine | 1.00000 | 33 | 0 |
| typeshed | 0.99978 | 3669 | 20 |
| warehouse | 0.99977 | 654 | 13 |
| zulip | 0.99970 | 1459 | 22 |

crates/ruff_python_ast/src/expression.rs

@@ -25,7 +25,12 @@ pub enum ExpressionRef<'a> {
     Call(&'a ast::ExprCall),
     FormattedValue(&'a ast::ExprFormattedValue),
     FString(&'a ast::ExprFString),
-    Constant(&'a ast::ExprConstant),
+    StringLiteral(&'a ast::ExprStringLiteral),
+    BytesLiteral(&'a ast::ExprBytesLiteral),
+    NumberLiteral(&'a ast::ExprNumberLiteral),
+    BooleanLiteral(&'a ast::ExprBooleanLiteral),
+    NoneLiteral(&'a ast::ExprNoneLiteral),
+    EllipsisLiteral(&'a ast::ExprEllipsisLiteral),
     Attribute(&'a ast::ExprAttribute),
     Subscript(&'a ast::ExprSubscript),
     Starred(&'a ast::ExprStarred),
@@ -64,7 +69,12 @@ impl<'a> From<&'a Expr> for ExpressionRef<'a> {
             Expr::Call(value) => ExpressionRef::Call(value),
             Expr::FormattedValue(value) => ExpressionRef::FormattedValue(value),
             Expr::FString(value) => ExpressionRef::FString(value),
-            Expr::Constant(value) => ExpressionRef::Constant(value),
+            Expr::StringLiteral(value) => ExpressionRef::StringLiteral(value),
+            Expr::BytesLiteral(value) => ExpressionRef::BytesLiteral(value),
+            Expr::NumberLiteral(value) => ExpressionRef::NumberLiteral(value),
+            Expr::BooleanLiteral(value) => ExpressionRef::BooleanLiteral(value),
+            Expr::NoneLiteral(value) => ExpressionRef::NoneLiteral(value),
+            Expr::EllipsisLiteral(value) => ExpressionRef::EllipsisLiteral(value),
             Expr::Attribute(value) => ExpressionRef::Attribute(value),
             Expr::Subscript(value) => ExpressionRef::Subscript(value),
             Expr::Starred(value) => ExpressionRef::Starred(value),
@@ -172,9 +182,34 @@ impl<'a> From<&'a ast::ExprFString> for ExpressionRef<'a> {
         Self::FString(value)
     }
 }
-impl<'a> From<&'a ast::ExprConstant> for ExpressionRef<'a> {
-    fn from(value: &'a ast::ExprConstant) -> Self {
-        Self::Constant(value)
+impl<'a> From<&'a ast::ExprStringLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprStringLiteral) -> Self {
+        Self::StringLiteral(value)
+    }
+}
+impl<'a> From<&'a ast::ExprBytesLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprBytesLiteral) -> Self {
+        Self::BytesLiteral(value)
+    }
+}
+impl<'a> From<&'a ast::ExprNumberLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprNumberLiteral) -> Self {
+        Self::NumberLiteral(value)
+    }
+}
+impl<'a> From<&'a ast::ExprBooleanLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprBooleanLiteral) -> Self {
+        Self::BooleanLiteral(value)
+    }
+}
+impl<'a> From<&'a ast::ExprNoneLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprNoneLiteral) -> Self {
+        Self::NoneLiteral(value)
+    }
+}
+impl<'a> From<&'a ast::ExprEllipsisLiteral> for ExpressionRef<'a> {
+    fn from(value: &'a ast::ExprEllipsisLiteral) -> Self {
+        Self::EllipsisLiteral(value)
     }
 }
 impl<'a> From<&'a ast::ExprAttribute> for ExpressionRef<'a> {
@@ -240,7 +275,14 @@ impl<'a> From<ExpressionRef<'a>> for AnyNodeRef<'a> {
             ExpressionRef::Call(expression) => AnyNodeRef::ExprCall(expression),
             ExpressionRef::FormattedValue(expression) => AnyNodeRef::ExprFormattedValue(expression),
             ExpressionRef::FString(expression) => AnyNodeRef::ExprFString(expression),
-            ExpressionRef::Constant(expression) => AnyNodeRef::ExprConstant(expression),
+            ExpressionRef::StringLiteral(expression) => AnyNodeRef::ExprStringLiteral(expression),
+            ExpressionRef::BytesLiteral(expression) => AnyNodeRef::ExprBytesLiteral(expression),
+            ExpressionRef::NumberLiteral(expression) => AnyNodeRef::ExprNumberLiteral(expression),
+            ExpressionRef::BooleanLiteral(expression) => AnyNodeRef::ExprBooleanLiteral(expression),
+            ExpressionRef::NoneLiteral(expression) => AnyNodeRef::ExprNoneLiteral(expression),
+            ExpressionRef::EllipsisLiteral(expression) => {
+                AnyNodeRef::ExprEllipsisLiteral(expression)
+            }
             ExpressionRef::Attribute(expression) => AnyNodeRef::ExprAttribute(expression),
             ExpressionRef::Subscript(expression) => AnyNodeRef::ExprSubscript(expression),
             ExpressionRef::Starred(expression) => AnyNodeRef::ExprStarred(expression),
@@ -277,7 +319,12 @@ impl Ranged for ExpressionRef<'_> {
             ExpressionRef::Call(expression) => expression.range(),
             ExpressionRef::FormattedValue(expression) => expression.range(),
             ExpressionRef::FString(expression) => expression.range(),
-            ExpressionRef::Constant(expression) => expression.range(),
+            ExpressionRef::StringLiteral(expression) => expression.range(),
+            ExpressionRef::BytesLiteral(expression) => expression.range(),
+            ExpressionRef::NumberLiteral(expression) => expression.range(),
+            ExpressionRef::BooleanLiteral(expression) => expression.range(),
+            ExpressionRef::NoneLiteral(expression) => expression.range(),
+            ExpressionRef::EllipsisLiteral(expression) => expression.range(),
             ExpressionRef::Attribute(expression) => expression.range(),
             ExpressionRef::Subscript(expression) => expression.range(),
             ExpressionRef::Starred(expression) => expression.range(),