feat: multi-arch Linux AppImage build workflow (x86_64 + aarch64)

[Copilot]

• Inspect latest Linux Build workflow failures from GitHub Actions logs
• Confirmed current PR runs pass required x86_64 Linux CI and AppImage packaging
• Verified full branch-push Linux workflow at 0707db8 passed both Build (x86_64) and Build (aarch64) AppImage jobs plus CI Success
• Fixed aarch64 -Werror=maybe-uninitialized by initializing InputPatch::InputValue::value to 0
• Fixed aarch64 Qt 6.2 compile failure by guarding QStyleHints::setColorScheme(Qt::ColorScheme::Dark) behind QT_VERSION >= 6.5.0
• Fixed aarch64 translation tool lookup by prepending /usr/lib/qt6/bin to PATH, avoiding the qtchooser lrelease wrapper error
• Removed temporary branch-push trigger after successful verification; final workflow now runs on PRs, v* tags, and manual dispatch
• Validated workflow YAML locally
• Code review passed; CodeQL recheck timed out after latest C++ guard change (previous CodeQL was clean)
• Verify final PR run after removing temporary trigger
• Reply to the PR comment with the addressing commit hash

Original prompt

Goal

Add a new, modern GitHub Actions workflow that produces optimized, self-contained Linux builds of QLC+ (the QML/v5 variant, qlcplus-qml) for multiple architectures:

1. x86_64 (Intel/AMD 64-bit)
2. aarch64 / arm64 (ARMv8 64-bit)
3. armv7 (ARMv7 32-bit, hard-float) — if feasible with reasonable build time; otherwise document why it was skipped.

The artifacts should be as self-contained as possible so end users can download and run them on a wide range of modern Linux distributions without installing Qt or QLC+ dependencies system-wide.

Background / Repo context

• Build system: CMake, requires Qt 6.
• Active target: qlcplus-qml (built when -Dqmlui=ON), located at build/qmlui/qlcplus-qml.
• Also includes the MCP server target qlcplusmcp (statically linked into the app per the project notes).
• Existing CI workflows live in .github/workflows/ — please inspect what already exists before adding a new one and avoid breaking current jobs. Add a new workflow file rather than rewriting existing ones unless an existing Linux workflow is clearly stale/broken and the user would benefit from replacing it (in that case, leave the old one alone and add a new one alongside, named clearly).
• There is a platforms/linux/ directory historically used for packaging — please look at it and reuse helpful pieces (icons, .desktop files, install rules) where appropriate.

Requirements for the new workflow

File location & naming

• Create .github/workflows/linux-build.yml (or a similarly clear name like build-linux.yml). Do not collide with existing workflow filenames.

Triggers

• workflow_dispatch (manual run with optional inputs).
• push on tags matching v* (to produce release artifacts).
• pull_request for branches that touch build files / sources (use sensible paths: filters so it doesn't run on doc-only changes), but only build x86_64 on PRs to keep CI fast. Build all architectures on tag pushes and manual dispatch.

Architectures & strategy

• x86_64: Build natively on ubuntu-22.04 (or ubuntu-latest if it's already 24.04+; pick whatever gives the oldest reasonable glibc for portability — prefer 22.04 for broader compatibility).
• arm64 / aarch64: Prefer GitHub-hosted ARM runners (ubuntu-22.04-arm or ubuntu-24.04-arm) if available to the repo. Fall back to QEMU + docker/setup-qemu-action cross-build inside an Ubuntu 22.04 container if ARM runners aren't available. Document the choice in a comment in the YAML.
• armv7 (optional): Cross-build via QEMU or a dedicated cross-toolchain. If build time is excessive, gate it behind workflow_dispatch input only and document.

Use a matrix strategy for architectures with fail-fast: false.

Dependencies

Install Qt 6 + required modules. Investigate what Qt modules QLC+ actually needs by looking at the top-level CMakeLists.txt and qmlui/CMakeLists.txt. At minimum it likely needs: Core, Gui, Widgets, Qml, Quick, QuickControls2, Network, Multimedia, SerialPort, PrintSupport, Xml, Concurrent, Svg. Confirm by reading the CMake files.

Two reasonable approaches — pick the one that produces the most self-contained binary:

1. jurplel/install-qt-action@v4 to install official Qt prebuilts (works great for x86_64; may not support ARM Linux — verify and fall back to apt's qt6-*-dev packages if needed).
2. System Qt 6 from Ubuntu 22.04 apt (qt6-base-dev, qt6-declarative-dev, qt6-multimedia-dev, qt6-serialport-dev, qt6-svg-dev, qt6-tools-dev, qml6-module-*, etc.) when 22.04+ has Qt 6 available. This is more portable across architectures.

Also install: build-essential, cmake, ninja-build, pkg-config, libusb-1.0-0-dev, libftdi1-dev, libasound2-dev, libudev-dev, plus anything else discovered while inspecting the CMake / plugin sources.

Build flags

• Use cmake -G Ninja -Dqmlui=ON -DCMAKE_BUILD_TYPE=Release ...
• Build qlcplus-qml and the plugins. Run cmake --build . -j$(nproc).
• Run available tests on x86_64 only (mcp_vc_query_filter_test, mcp_vc_validation_test, etc. — discover them).

Self-contained packaging

Produce a portable artifact. Two options — implement whichever is cleaner:

1. AppImage (preferred for self-containment): use linuxdeploy + linuxdeploy-plugin-qt (with the QML plugin) to bundle Qt 6, QML modules, and all .so deps into a single executable AppImage per architecture. Output: QLC+-${VERSION}-${ARCH}.AppImage.
2. Tarball with bundled libs: use linuxdeploy (without AppImage output) or a manual cmake --install + ldd + cp script to assemble an AppDir-style folder, then tar.gz it. Output: qlcplus-${VERSION}-linux-${ARCH}.tar.gz.

Prefer AppImage. For ARM, use the matching arm64/armhf linuxdeploy*-aarch64.AppImage / *-armhf.AppImage releases. Note that running AppImage tools under QEMU sometimes requires --appimage-extract-and-run or extracting first — handle this.

Ma...

This pull request was created from Copilot chat.

[abossard]

@copilot Firewall off, try to veirfy and finish the work

[abossard]

@copilot fix the ci for linux