internal: more reasonable grammar for blocks

Consider these expples

        { 92 }
  async { 92 }
    'a: { 92 }
   #[a] { 92 }

Previously the tree for them were

  BLOCK_EXPR
    { ... }

  EFFECT_EXPR
    async
    BLOCK_EXPR
      { ... }

  EFFECT_EXPR
    'a:
    BLOCK_EXPR
      { ... }

  BLOCK_EXPR
    #[a]
    { ... }

As you see, it gets progressively worse :) The last two items are
especially odd. The last one even violates the balanced curleys
invariant we have (#10357) The new approach is to say that the stuff in
`{}` is stmt_list, and the block is stmt_list + optional modifiers

  BLOCK_EXPR
    STMT_LIST
      { ... }

  BLOCK_EXPR
    async
    STMT_LIST
      { ... }

  BLOCK_EXPR
    'a:
    STMT_LIST
      { ... }

  BLOCK_EXPR
    #[a]
    STMT_LIST
      { ... }

crates/syntax/src/validation/block.rs

@@ -9,14 +9,16 @@ use crate::{
 pub(crate) fn validate_block_expr(block: ast::BlockExpr, errors: &mut Vec<SyntaxError>) {
     if let Some(parent) = block.syntax().parent() {
         match parent.kind() {
-            FN | EXPR_STMT | BLOCK_EXPR => return,
+            FN | EXPR_STMT | STMT_LIST => return,
             _ => {}
         }
     }
-    errors.extend(block.attrs().filter(|attr| attr.kind().is_inner()).map(|attr| {
-        SyntaxError::new(
-            "A block in this position cannot accept inner attributes",
-            attr.syntax().text_range(),
-        )
-    }))
+    if let Some(stmt_list) = block.stmt_list() {
+        errors.extend(stmt_list.attrs().filter(|attr| attr.kind().is_inner()).map(|attr| {
+            SyntaxError::new(
+                "A block in this position cannot accept inner attributes",
+                attr.syntax().text_range(),
+            )
+        }))
+    }
 }