feat: update max-statements for class static blocks

[mdjermanovic]

Prerequisites checklist

• I have read the contributing guidelines.

What is the purpose of this pull request? (put an "X" next to an item)

[ ] Documentation update
[ ] Bug fix (template)
[ ] New rule (template)
[x] Changes an existing rule (template)
[ ] Add autofixing to a rule
[ ] Add a CLI option
[ ] Add something to the core
[ ] Other, please explain:

Refs #15016, fixes max-statements.

What changes did you make? (Give an overview)

Updated the max-statements rule so that it does not apply to class static blocks and does not count statements in them as statements of the enclosing function.

Is there anything you'd like reviewers to focus on?

Before this change, the behavior of this rule was:

/* eslint max-statements: ["error", 2] */

function foo() {
    var x; // 1
    return class { // 2
        static {
            var y; // doesn't count
            var z; // doesn't count
            var p; // doesn't count
            {
                var q; // 3
                var r; // 4
                var s; // 5
            }
        }
    }
}

 Function 'foo' has too many statements (5). Maximum allowed is 2. (max-statements)

Statements at the top level of static blocks did not count at all. Statements in nested blocks of static blocks did count, as statements of the enclosing function.

This didn't make sense, and possible fixes were:

1. Treat static blocks as blocks in the enclosing function, and count all statements. In that case, foo would have 8 statements.
2. Treat static blocks as inner functions. In that case, foo would have 2 statements, while the static block itself would be reported as it would have 6 statements.
3. Ignore all statements in static blocks. In that case, foo would have 2 statements, while the static block and its nested blocks would be ignored.

I implemented option 3.

/* eslint max-statements: ["error", 2] */

function foo() {
    var x; // 1
    return class { // 2
        static { // ignored, the rule does not apply
            var y; // doesn't count
            var z; // doesn't count
            var p; // doesn't count
            {
                var q; // doesn't count
                var r; // doesn't count
                var s; // doesn't count
            }
        }
    }
}

I think that static block shouldn't be seen as a block in the function (option 1). Both options 2 and 3 make sense to me, but the documentation for this rule states multiple times that it applies to "functions", so given the conversation in #15016, it looked like this rule should not apply to static blocks, or at least not by default.

[nzakas]

LGTM. I agree with the treatment of static blocks. 👍