Add the concept of an active query

No se especifican archivos ni pruebas del repositorio. Empieza por localizar el registro de la extensión para el comando codeQL.runQuery y la gestión del estado del espacio de trabajo de VS Code que se muestra en la prueba de concepto. La tarea debería incluir una forma de elegir un archivo .ql abierto como consulta activa y ejecutarlo desde otro archivo, permitiendo al mismo tiempo que la consulta de la pestaña activa siga teniendo prioridad.

Is your feature request related to a problem? Please describe.
When I'm working on a query I'm often in editing other files like .qll files, but still want to run the primary query after making a change. I'm in the habit of pressing the key binding for running a query, but this doesn't work from .qll files, so I need to switch tabs back to the original query and then run it. This gets annoying over time.

Describe the solution you'd like
If I know I only want to work on a single query, it would be useful to specify this query once, and then have a key binding for running the active query from any file.

Additional context
I've prototyped this feature in a separate extension and it's been working well for me:

    function getQLFileFromTab(tab: vscode.Tab): string | null {
        if (tab.input === undefined) {
            return null;
        }
        const tabInput = tab.input as vscode.TabInputText
        if (tabInput.uri === undefined) {
            return null;
        }
        const path: string = tabInput.uri.fsPath
        if (path.endsWith(".ql")) {
            return path
        }

        return null;
    }

    context.subscriptions.push(vscode.commands.registerCommand('gsgx.runActiveCodeQLQuery', async () => {
        const activeTab = vscode.window.tabGroups.activeTabGroup.activeTab
        let activeTabPath = null;
        if (activeTab !== undefined) {
            activeTabPath = getQLFileFromTab(activeTab)
            if (activeTabPath !== null) {
                vscode.commands.executeCommand("codeQL.runQuery",
                    vscode.Uri.file(activeTabPath)
                );
                return;
            }
        }

        const activeQuery = <string>context.workspaceState.get("codeql.active-query");
        if (activeQuery) {
            vscode.commands.executeCommand("codeQL.runQuery",
                vscode.Uri.file(activeQuery)
            );
        } else {
            vscode.window.showInformationMessage('No active query');
        }
    }));


    class QLFileQuickPickItem implements vscode.QuickPickItem {
        label: string;
        path: string;
        detail: string;
        constructor(path: string) {
            this.path = path
            this.detail = path
            this.label = basename(path)
        }
    }
    context.subscriptions.push(vscode.commands.registerCommand('gsgx.setActiveCodeQLQuery', async () => {
        let openFiles = []

        const activeTab = vscode.window.tabGroups.activeTabGroup.activeTab
        let activeTabPath = null;
        let activeTabFiles = []
        if (activeTab !== undefined) {
            activeTabPath = getQLFileFromTab(activeTab)
            if (activeTabPath !== null) {
                activeTabFiles.push(new QLFileQuickPickItem(activeTabPath))
            }
        }
        console.log(activeTabPath)


        for (const tg of vscode.window.tabGroups.all) {
            for (const tab of tg.tabs) {
                const path = getQLFileFromTab(tab)
                if (path === null) {
                    continue
                }
                const item = new QLFileQuickPickItem(path)
                if (tab.isActive) {
                    if (activeTabPath != path) {
                        activeTabFiles.push(item)
                    }
                } else {
                    openFiles.push(item)
                }
            }
        }

        // activeTabFiles come first
        openFiles.unshift(...activeTabFiles)
        if (openFiles.length != 0) {
            const result = await vscode.window.showQuickPick(openFiles, {
                title: "Query path",
                canPickMany: false,
            });
            await context.workspaceState.update("codeql.active-query", result?.path)
        } else {
            vscode.window.showInformationMessage("No CodeQL files are open")
        }
    }));

This is just a proof of concept to start a discussion about how this feature should work, if you think it makes sense to add it.

In this implementation, you can set any QL file that is in an open tab to the active query (in addition to this, it would probably be good to have an option in the right click context menu in the file explorer to set an active query).

Also, if another .ql file is in the active tab, it will always run that QL file instead of the active one. The reason for this is I occasionally do need to run other queries, but don't want to change the active query. It's convenient and intuitive to always run the query in the active tab first, and if the active tab is not a .ql file, then run the active query.

Please let me know what you think.