[Feature request] Add a pseudo-type for custom require-like functions

Nadie ha tomado este issue todavía.

I think it would be useful to have something like a `Require`-type. This type would take a literal string type `T` and evaluate as the same type that calling `require(modname: T)` would. This way, a wrapper around `require` could easily be built like this:

```lua
--- Require a module, throwing an error if it returned `true` (meaning that you
--- probably forgot to actually return something from it).
---@generic T : string
---@param module_name T
---@return Require module -- <-- Note the use of `Require`
local function checked_require(module_name)
assert(type(module_name) == "string", "The `module_name` must be a string!")

local module = require(module_name)

assert(
module ~= true,
string.format(
"Could not import module: `require(%q)` returned `true`!",
module_name
)
)

return module
end

--------------------------------------------------------------------------------

local socket = checked_require("socket")
local socket_require = require("socket")

assert(socket == socket_require)
```

The type-hint of `require()` could then be changed to the following:

```lua
---@generic T : string
---@param module_name T
---@return Require module
function require(module_name) end
```

The language server already has a way to make global functions behave like `require` built-in, in the form of the `"Lua.runtime.special"` setting. This type would essentially do the same, except that it would be more powerful / broadly usable, since it could be applied to any variable. It would also be easier to use, since it's just another type in your code instead of something hiding in a config file.

Empieza rastreando cómo el servidor de lenguaje gestiona las sugerencias de tipo de require() y la configuración Lua.runtime.special. Define qué debería hacer Require para nombres de módulo literales, wrappers y el ejemplo mostrado de checked_require; se considera terminado cuando el wrapper y el require directo se resuelven al mismo tipo de módulo.

Escrito por el modelo de indexación a partir del texto del issue.