Add `upvalue` semantic token modifier

Personne n'a encore pris cette issue.

LuaLS should expose whether a `variable` reference is an upvalue through a new `upvalue` semantic token modifier.

Currently, local variables and upvalues are both reported as:

```text
semantic token type: variable
modifiers: -
```

while globals are already distinguished using:

```text
semantic token type: variable
modifiers: global
```

This makes it impossible for editors such as VS Code to visually distinguish local variables from upvalues.

## Example

```lua
local function outer()
local value = 123

return function()
print(value) -- upvalue
end
end
```

Currently the `value` reference inside the inner function is:

```text
variable
```

It would be useful for LuaLS to report it as:

```text
variable + upvalue
```

while the declaration remains:

```text
variable
```

## Proposed semantic token model

```text
variable -> local variable
variable + upvalue -> upvalue
variable + global -> global variable
parameter -> function parameter
```

For example:

```lua
local foo = 1

local function outer(bar)
local baz = 2

return function(qux)
print(foo) -- upvalue
print(bar) -- upvalue
print(baz) -- upvalue
print(qux) -- parameter
print(print) -- global
end
end
```

would produce approximately:

```text
foo -> variable + upvalue
bar -> variable + upvalue
baz -> variable + upvalue
qux -> parameter
print -> variable + global
```

Ordinary locals would remain simply:

```text
variable
```

## Why a modifier?

A modifier seems preferable to introducing a new semantic token type because `upvalue` describes a property of a variable reference rather than a fundamentally different kind of symbol.

It also fits the existing LuaLS representation of globals:

```text
variable + global
```

This gives editor themes a simple way to distinguish all four cases:

```text
variable
variable + upvalue
variable + global
parameter
```

## Scope

The `upvalue` modifier should be applied to references resolved to a variable declared in an enclosing lexical scope.

For example:

```lua
local x = 1

local function f()
print(x)
end
```

would be:

```text
x declaration -> variable
x reference -> variable + upvalue
```

Nested closures should work recursively.

## Motivation

This would allow VS Code themes to use different colors for locals, parameters, upvalues, and globals, making lexical scope much easier to understand in closure-heavy Lua/LuaJIT code.

LuaLS already performs the necessary lexical-scope resolution; this proposal would expose that information through semantic tokens.

L’issue ne mentionne aucun fichier ni test. Commencez par localiser la génération des tokens sémantiques de LuaLS et la résolution de la portée lexicale utilisée pour les références aux variables ; suivez la façon dont le modificateur global existant est attribué. Le travail est terminé lorsque les références résolues vers des variables d’une portée englobante reçoivent un modificateur upvalue, que les déclarations et les variables locales ordinaires restent inchangées, et que les closures imbriquées sont couvertes par des tests.

Rédigé par le modèle d'indexation à partir du texte de l'issue.