refactor(parser): drop redundant hasTopLevelBareVariable scan

#4462 added a hand-rolled hasTopLevelBareVariable() that re-scanned prelude text
with a paren-depth counter to flag a top-level bare @variable. It duplicated
machinery the parser already has and was subtly wrong:
  - permissiveValue's entity loop already reports a bare @var structurally (it
    parses a Variable entity and warns), covering every real case — bare, glued
    (bar-@baz), post-keyword (@A and @b), and comma lists — verified.
  - the hand-rolled scan only tracked (), not []/{} or strings, unlike the
    existing nesting-aware $parseUntil, so a bare @var inside […] could be
    mis-flagged.
Remove the function and suppress the value-context 'variable-in-unknown-value'
notice for at-rule preludes (the entity loop owns that warning). Behaviour is
unchanged: the at-rule-variable-deprecated fixture renders byte-identically and
emits the same 5 prelude warnings; @foo (x:@v) still does not warn.

Author: matthew-dean

packages/less/lib/less/parser/parser.js

@@ -106,31 +106,6 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
         warn('A bare @variable in an at-rule prelude is deprecated. Use @{variable} interpolation instead.', index, 'DEPRECATED', 'variable-in-at-rule-prelude');
     }
 
-    /**
-     * Whether `text` contains a bare `@variable` at the top level — i.e. outside
-     * any `(...)` group. A `@variable` inside parentheses is a declaration value
-     * (e.g. the `@v` in `@supports (display: @v)`) and remains valid; only a bare
-     * `@variable` in a structural position is deprecated.
-     *
-     * @param {string} text
-     * @returns {boolean}
-     */
-    function hasTopLevelBareVariable(text) {
-        let depth = 0;
-        for (let j = 0; j < text.length; j++) {
-            const c = text.charAt(j);
-            if (c === '(') {
-                depth++;
-            } else if (c === ')') {
-                if (depth > 0) { depth--; }
-            } else if (c === '@' && depth === 0) {
-                // a bare `@ident`, not `@{ident}` interpolation
-                if (/[\w-]/.test(text.charAt(j + 1))) { return true; }
-            }
-        }
-        return false;
-    }
-
     function expect(arg, msg) {
         // some older browsers return typeof 'function' for RegExp
         const result = (arg instanceof Function) ? arg.call(parsers) : parserInput.$re(arg);
@@ -1838,14 +1813,13 @@ const Parser = function Parser(context, imports, fileInfo, currentIndex) {
                             const quote = new tree.Quoted('\'', item, true, index, fileInfo);
                             const variableRegex = /@([\w-]+)/g;
                             const propRegex = /\$([\w-]+)/g;
-                            if (deprecateVariables) {
-                                // At-rule prelude: only a bare @var in a structural
-                                // (top-level) position is deprecated; @vars inside
-                                // `(...)` are declaration values and stay valid.
-                                if (hasTopLevelBareVariable(item)) {
-                                    warnBareAtRuleVariable(index);
-                                }
-                            } else if (variableRegex.test(item)) {
+                            // A bare `@var` in an at-rule prelude (deprecateVariables)
+                            // is already reported structurally by the entity loop
+                            // above (a parsed `Variable` entity), so no text re-scan is
+                            // needed here. The `variable-in-unknown-value` notice below
+                            // is for unknown declaration values only, not at-rule
+                            // preludes, so it is suppressed when deprecateVariables.
+                            if (!deprecateVariables && variableRegex.test(item)) {
                                 warn('@variable in unknown values will not be evaluated as variables in the future. Use @{variable}', index, 'DEPRECATED', 'variable-in-unknown-value');
                             }
                             if (propRegex.test(item)) {