This commit implements the AST design to account for implicit
concatenation in string nodes, specifically the `ExprFString`,
`ExprStringLiteral`, and `ExprBytesLiteral` nodes.

This commit adds the new variants for the string parts to `AnyNode` and
`AnyNodeRef` enums. These parts are `StringLiteral` (part of
`ExprStringLiteral`), `BytesLiteral` (part of `ExprBytesLiteral`), and
`FString` (part of `ExprFString`).

The reason for this is to add visitor methods for these parts. This is
done in the following commit. So, the visitor would visit the string as
a whole first and then visit each part.

```
ExprStringLiteral - "foo" "bar"
|- StringLiteral - "foo"
|- StringLiteral - "bar"
```

The above tree helps understand the way visitor would work.

The visitor implementations are updated to visit each part nodes for the
respective string nodes.

The following example better highlights this:
```
ExprStringLiteral - "foo" "bar"
|- StringLiteral - "foo"
|- StringLiteral - "bar"
```

The `visit_expr` method would be use to visit the `ExprStringLiteral`
while the `visit_string_literal` method would be use for the
`StringLiteral` node. Similar methods are added for bytes and f-strings.

The generator is basically improved. Earlier, for an implicitly
concatenated string we would produce the joined form. So,

```python
"foo" "bar" "baz"
```

For the above example, the generator would give us:
```python
"foobarbaz"
```

Now, as we have the information for each part, we will be producing the
exact code back.

`Expr` is a general type for all expressions while
`LiteralExpressionRef` is a type which includes only the literal
expressions. The method is suited more for this type instead.

This will also help in the formatter change.

As highlighted in the review:

> If you have two `ConcatenatedStringLiteral` values where both have
> equivalent values for `strings` but where one has `value` initialized
> and the other does not, would you expect them to compare equal?
> Semantically I think I would, since the alternative is that equality is
> dependent on whether `as_str()` has been called, which seems incidental.

#7927 (comment)