Currently, variables defined by Ext:Arrays, Ext:Variables, and similar extensions have global scope - that is, if a variable is defined at the top of a page, it can be accessed at any other point on that page, even in template calls (and if you use Ext:Variables' #var_final, the variable doesn't even have to be defined before this usage, so a usage could be at the top of a page while the definition is at the bottom). Arguably, this is the functionality that makes these extensions so useful in the first place; in particular, it is the entire point of Ext:Variables.
However, it is usually not necessary to have these variables in the scope of the entire page, and often enough is even counterproductive: it is all too easy to define a variable in a template with a given name, and then to have another template check for a variable by that name, where the intention is that the second template is setting the variable itself. There are a couple of workarounds to this, of course: careful variable naming, especially by prefixing the template name, will all but eliminate accidental variable leakage between templates, an making a point to reset all variables used by a template at the end of that template, or to always set variables used by the template at the beginning of that template, also prevents leakage, but the former often leads to awkward names, and the latter introduces code bloat and duplication that would be better avoided.
I think the better solution here would be to introduce a scoping mechanism to these extensions, and require either explicitly listing variables which should be global instead of local, listing global variables which should be "imported" into the current local scope, or both. The actual mechanism could be one or more new parser functions, a new mode(s) on the current parser functions, or something else; I don't claim to have much in the way of good ideas here.