refactor(ast): remove AstKind for PropertyKey (#12108)

- part of #11490

This removes the `PropertyKey` AstKind, in support of making the AST kinds more consistent (i.e., only `struct`s should be visited in the AST).

Similar to past PRs, I've added a new `PropertyKeyKind` to narrow the `AstKind` enum (related: oxc-project/backlog#166).

Comments on various changes:
- `id_length` rule: I had to add new handling for nodes which were previously covered by visting `PropertyKey`.
- `no_magic_numbers` rule: Similar to `id_length`, we need to be more careful when checking if a value is part of a class property initializer, since we can't fully rely on the parent kind anymore.
- `prefer_dom_node_text_content` rule: the ancestry here has changed, fortunately for the better in this case. some of the previous juggling of parent/grandparent has been replaced with a simpler check.
- `prefer_string_raw`: the logic for `PropertyKey` was already fully covered by `ObjectProperty`, so I've removed it.
- Semantic binder changes: I added an additional check for binding the `SetAccessor` scope flags which ensures that we only set it when a function is part of a property definition's value, not its key. This evidenced as a test failure in the `no_setter_return` lint rule.

Author: camchenry

crates/oxc_ast/src/ast_kind_impl.rs

@@ -123,6 +123,18 @@ impl<'a> AstKind<'a> {
         }
     }
 
+    pub fn is_property_key(&self) -> bool {
+        self.as_property_key_kind().is_some()
+    }
+
+    pub fn as_property_key_kind(&self) -> Option<PropertyKeyKind<'a>> {
+        match self {
+            Self::IdentifierName(ident) => Some(PropertyKeyKind::Static(ident)),
+            Self::PrivateIdentifier(ident) => Some(PropertyKeyKind::Private(ident)),
+            _ => None,
+        }
+    }
+
     pub fn from_expression(e: &'a Expression<'a>) -> Self {
         match e {
             Expression::BooleanLiteral(e) => Self::BooleanLiteral(e),
@@ -291,7 +303,6 @@ impl AstKind<'_> {
             Self::ObjectProperty(p) => {
                 format!("ObjectProperty({})", p.key.name().unwrap_or(COMPUTED)).into()
             }
-            Self::PropertyKey(p) => format!("PropertyKey({})", p.name().unwrap_or(COMPUTED)).into(),
             Self::Argument(_) => "Argument".into(),
             Self::AssignmentTarget(_) => "AssignmentTarget".into(),
             Self::SimpleAssignmentTarget(a) => {
@@ -559,3 +570,19 @@ impl GetSpan for ModuleDeclarationKind<'_> {
         }
     }
 }
+
+pub enum PropertyKeyKind<'a> {
+    /// A static identifier property key, like `a` in `{ a: 1 }`.
+    Static(&'a IdentifierName<'a>),
+    /// A private identifier property key, like `#a` in `class C { #a = 1 }`.
+    Private(&'a PrivateIdentifier<'a>),
+}
+
+impl GetSpan for PropertyKeyKind<'_> {
+    fn span(&self) -> Span {
+        match self {
+            Self::Static(ident) => ident.span,
+            Self::Private(ident) => ident.span,
+        }
+    }
+}