Improve flexibility around vendored librariesmain

compat53 is vendored since #1757 as it is required to run luarocks with lua 5.1 or 5.2.

However, this introduced some issues as the GNUmakefile install rule places these in the same place where `luarocks install compat53` would install them. This means you get conflicts if you install the actual package:
```
Warning: /.../prefix/share/lua/5.1/compat53/init.lua is not tracked by this installation of LuaRocks. Moving it to /.../prefix/share/lua/5.1/compat53/init.lua~
Warning: /.../prefix/share/lua/5.1/compat53/module.lua is not tracked by this installation of LuaRocks. Moving it to /.../prefix/share/lua/5.1/compat53/module.lua~
Warning: /.../prefix/share/lua/5.1/compat53/file_mt.lua is not tracked by this installation of LuaRocks. Moving it to /.../prefix/share/lua/5.1/compat53/file_mt.lua~
```

It is also not ideal for linux package maintainers to include a vendored package, see: https://github.com/luarocks/luarocks/pull/1757#issuecomment-3409873412.

To solve these issues, this patchset makes the following changes:
- GNUmakefile now places the compat53 files under `luarocks/vendor/compat53` (which is added internally to the luarocks script's `package.path`). This way a user's installation of compat53 does not interfere at all with luarocks one.
- Added `--with-system-compat53` option to configure script for external packaging systems.
- Fixed install.bat's logic for deciding whether to vendor compat53, as the current script includes it for every version.

install.bat already places luarocks sources outside of LUAPATH, so that part can stay as is.

I've also inverted the version check to avoid the need for future patches like: #1850.

1 files changed, 111 insertions, 0 deletions

diff --git a/vendor/argparse.d.tl b/vendor/argparse.d.tl
new file mode 100644
index 00000000..812786c4
--- /dev/null
+++ b/vendor/argparse.d.tl
@@ -0,0 +1,111 @@
+
+local record argparse
+        type Args = {string : {string} | string | boolean}
+
+        record Parser
+                name: function(self: Parser, name: string): Parser
+                description: function(self: Parser, description: string): Parser
+                epilog: function(self: Parser, epilog: string): Parser
+
+                flag: function(self: Parser, flag: string): Option
+                flag: function(self: Parser, shortalias: string, longalias: string): Option
+
+                parse: function(self: Parser, argv: {string}): Args
+                pparse: function(self: Parser, argv: {string}): boolean, Args | string
+
+                error: function(self: Parser, error: string)
+
+                argument: function(self: Parser, name: string, description: string): Argument
+
+                get_usage: function(self: Parser): string
+                get_help: function(self: Parser): string
+
+                option: function(self: Parser, name: string, description?: string, default?: string, convert?: function | {function}, args?: {string}, count?: integer | string): Option
+                option: function(self: Parser, name: string, description?: string, default?: string, convert?: {string:string}, args?: {string}, count?: integer | string): Option
+
+                require_command: function(self: Parser, require_command: boolean): Parser
+                command_target: function(self: Parser, command_target: string): Parser
+
+                command: function(self: Parser, name: string, description: string, epilog: string): Command
+
+                add_help: function(self: Parser, boolean)
+
+                help_max_width: function(self: Parser, number): Parser
+                add_help_command: function(self: Parser, ?string | {string: any}): Parser
+                add_complete_command: function(self: Parser, ?string | {string: any}): Parser
+
+                group: function(self: Parser, ...:any): Parser
+
+                -- TODO: should be Argument | Option
+                mutex: function(self: Parser, ...: any)
+
+                record Opts
+                        name: string
+                        description: string
+                        epilog: string
+                end
+                metamethod __call: function(Parser, Opts): Parser
+                metamethod __call: function(Parser, string, string, string): Parser
+        end
+
+        type ActionCallback = function(args: Args, index: string, val: string | boolean | {string}, overwrite: boolean)
+
+        record Argument
+                choices: function(self: Argument, choices: {string}): Argument
+
+                convert: function(self: Argument, convert: function | {function}): Argument
+                convert: function(self: Argument, convert: {string:string}): Argument
+
+                args: function(self: Argument, args: string | integer): Argument
+
+                action: function(self: Argument, cb: ActionCallback)
+        end
+
+        record Option
+                name: function(self: Option, name: string): Option
+                description: function(self: Option, description: string): Option
+
+                argname: function(self: Option, argname: string | {string}): Option
+
+                count: function(self: Option, count: integer | string): Option
+
+                choices: function(self: Option, {string}): Option
+
+                default: function(self: Option, string): Option
+
+                defmode: function(self: Option, string): Option
+
+                target: function(self: Option, target: string): Option
+
+                args: function(self: Option, args: string|integer): Option
+
+                action: function(self: Option, cb: ActionCallback)
+
+                hidden_name: function(self: Option, string)
+
+                hidden: function(self: Option, boolean)
+
+                convert: function(self: Option, function)
+        end
+
+        record Command
+                summary: function(self: Command, summary: string): Command
+                description: function(self: Command, description: string): Command
+
+                argument: function(self: Command, name: string, description?: string): Argument
+
+                option: function(self: Command, name: string, description: string): Option
+
+                flag: function(self: Command, string, ?string): Option
+
+                handle_options: function(self: Command, boolean): Command
+
+                mutex: function(self: Command, ...: any) --! copied over from Parser
+
+                group: function(self: Command, ...:any): Command --! copied over from Parser
+        end
+
+        metamethod __call: function(self: argparse, name: string, description: string, epilog: string): Parser
+end
+
+return argparse