[Icons] Tint semantic glyphs and add badge and sticker treatments (#7775)

* [Icons] Keep semantic red and green on themed glyphs

The one-glyph cutover recolored every icon from a single palette role, so a
disabled deck, a not-ready player and a remove button all lost the red or green
that carried their meaning.

Add Positive and Negative application colors beside the accents, ship
scheme-appropriate defaults for every theme, and resolve them through
ThemeManager. Icons now take an IconTint: a palette role for structural glyphs,
or a semantic role for states and add/remove actions. A disabled semantic icon
falls back to the disabled foreground; on a selected row a semantic tint keeps
its color only while it stays legible on the highlight, and a palette tint keeps
the existing WindowText -> HighlightedText swap.

* [Icons] Render a semantic-tint sheet for every shipped theme

The PR showed two sheets for one theme, which cannot show that the shipped
reds and greens stay legible on every palette. Each shipped theme and scheme
now gets its own sheet: both families, three glyphs, at 16 and 24 px, on the
window and button surfaces the contrast is measured against, with the
disabled tone beside each family.

The generator lives in its own test file so the preview work does not have to
move the branches above it.

* [Icons] Add a badge icon treatment

Restore the filled-disc look the ready/not-ready icons had before the
one-glyph cutover, without bringing back palette-locked art.

IconStyle::Badge composes the existing sentinel SVG at paint time: a
gradient disc, a dark ring, and the glyph re-weighted and inked for
contrast against the tone. Line stays the default and is unchanged.

Only the two state icons opt in. The add/remove icons keep the line
treatment because their old art was a filled glyph with an outline and
no disc, so badging them would invent a look the UI never had. Disabled
badges fall back to the line glyph so an unavailable control still reads
as unavailable.

* [Icons] Add a sticker icon treatment

The pre-#7595 add, remove and delete icons were filled shapes with a black
outline and no disc. A tint cannot bring that back, and the badge disc is a
different icon language, so add a third value to the existing style axis.

IconStyle::Sticker draws the sentinel glyph twice: a near-black rim at the
band width plus one rim on each side, then the tone pass clipped to the glyph
and filled with a vertical gradient. Both treatments keep the disabled
fallback to the line glyph.

The fill rule moves into theme_icon_fill: the semantic tones are tuned for
text, so a filled shape gives its tone a saturation floor, and a dark-scheme
tone is pulled down rather than up. IconTint::resolve() applies the same floor
to line glyphs, and the badge disc uses the same fill, so a line, a badge and
a sticker next to each other carry the same green or red instead of a pale
line beside a saturated glyph.

The badge's glyph ink follows the scheme: white on light-scheme tones, as in
the pre-#7595 art, and the saturated tone darkened to an outline-dark ink on
dark-scheme tones, where the shared saturated disc is light enough that white
would sit near 2.7:1. The new test pins both cases so the glyph cannot
silently flip.

resolveSvgStrokeWidth() moves the stroke-width rewrite into
libcockatrice_utility so the badge and the sticker share it; the badge's local
copy is gone.

The sticker is opted into at 17 call sites: increment, decrement and
remove_row in the deck editor, settings pages, token dialog, server dialogs
and replay/deck storage tabs. The visual database's clear-filter button keeps
its trash can (icons/delete) in the line treatment: that glyph is new in
#7595, but it is the clearer metaphor, and a sticker rim closes its lid gap
at toolbar sizes.

The preview generators also gain a semantic-tint sheet for #7775 and a
line/badge/sticker family strip, so the three PR descriptions can show the
same rendered colors.

* [Icons] Render authored theme SVG art without the SVG image plugin

`QPixmap("theme:file.svg")` needs Qt's SVG *image-format* plugin. Debian
builds that as the separate `qt6-svg-plugins` package, which is only a
Recommends of `qt6-svg-dev`, so a `--no-install-recommends` install (CI,
minimal user installs) does not have it. Authored theme art then loaded as
a null pixmap: the two authored-art render tests failed on Debian 13 and on
the Ubuntu sanitize leg while passing on a developer machine whose Qt
bundles the format.

Render authored SVG assets through QSvgRenderer instead, which is already
linked for the sentinel path and needs no plugin. Raster assets keep the
QPixmap loader. The test suite now hides the plugin directories, so the
dependency cannot come back unnoticed on platforms that ship the plugin.

* [Icons] Render a badge/sticker sheet for every shipped theme

The PR showed one theme's badge and sticker sheets, which cannot show that the
filled treatments read on every palette. Each shipped theme and scheme now
gets its own sheet: both semantic families, three glyphs, as line glyphs,
stickers and badges, at 16 and 24 px, on the window and button surfaces the
contrast is measured against, with the disabled fallback under each family.

The generator lives in its own test file so the preview work does not have to
move the branches above it.

* [Icons] Show the trash can with the sticker treatment again

The sticker sheet kept the delete glyph out of the sticker rows and explained
why: at toolbar sizes the rim closed the lid gap. The icon is used with the
sticker treatment again for destructive actions, so the sheet now shows it and
the exception note is gone.

* [Icons] Apply the CI clang-format output to the treatment preview

clang-format 18 wraps the family label and the glyph x offset differently from
the local clang-format 23. The preview test takes the CI output so the bottom
of the stack passes the style job on its own.

* [Icons] Rewrite the icon role docs in plain language

Address review: drop the AI-cadence prose from the IconStyle/IconTint and treatment headers, use ///< for the enum member docs, and move theme_icon.cpp's anonymous namespace above the IconTint definitions. No behavior change.

* Address review findings

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/interface/theme_icon_badge.cpp

@@ -0,0 +1,137 @@
+#include "theme_icon_badge.h"
+
+#include "libcockatrice/utility/svg_recolor.h"
+#include "theme_icon_fill.h"
+
+#include <QLinearGradient>
+#include <QPainter>
+#include <QPen>
+#include <QPointF>
+#include <QRectF>
+#include <QSvgRenderer>
+#include <QtGlobal>
+#include <cmath>
+
+namespace
+{
+// The pre-#7595 badge art filled almost the whole canvas: a 24px icon carried a
+// 23px disc with a hairline black outline. Keep the disc large and the ring
+// thin so the glyph still has room at 16px.
+constexpr double RING_WIDTH_RATIO = 0.04;
+// The sentinel paths sit inside a padded 24-unit viewBox (the check spans 4..20),
+// so the glyph box has to be nearly the whole disc for the engraved mark to
+// match the old art's weight. At half the disc it read as a smudge at 15px.
+constexpr double GLYPH_DIAMETER_RATIO = 0.9;
+// The sentinel set is drawn at 2 units in a 24-unit viewBox, which turns into a
+// hairline once the glyph is scaled into a 15px disc. The old badge carried a
+// band near a tenth of the disc diameter, so the badge decides the glyph weight
+// instead of inheriting the authored one.
+constexpr qreal GLYPH_STROKE_WIDTH = 3.0;
+constexpr int RING_DARKER = 300;
+constexpr int GLYPH_DARKER = 400;
+} // namespace
+
+namespace
+{
+struct DiscFill
+{
+    QColor top;
+    QColor bottom;
+};
+
+DiscFill discFill(const QColor &tone)
+{
+    return {ThemeIconFill::topColor(tone), ThemeIconFill::bottomColor(tone)};
+}
+} // namespace
+
+namespace ThemeIconBadge
+{
+double relativeLuminance(const QColor &color)
+{
+    const auto linear = [](double channel) {
+        channel /= 255.0;
+        return channel <= 0.03928 ? channel / 12.92 : std::pow((channel + 0.055) / 1.055, 2.4);
+    };
+    return 0.2126 * linear(color.red()) + 0.7152 * linear(color.green()) + 0.0722 * linear(color.blue());
+}
+
+double contrastRatio(const QColor &first, const QColor &second)
+{
+    const double a = relativeLuminance(first);
+    const double b = relativeLuminance(second);
+    return (qMax(a, b) + 0.05) / (qMin(a, b) + 0.05);
+}
+
+QColor glyphColor(const QColor &tone)
+{
+    // The badge carries the ink the pre-sticker badge did: white on the light
+    // scheme, and the tone darkened to an outline-dark ink on the dark scheme.
+    // The shared saturated disc is light enough there that white sits near
+    // 2.7:1 at the top, so the dark ink is the deliberate choice rather than a
+    // contrast measurement that a palette tweak could flip. Deriving it from
+    // the tone keeps themes in control.
+    return ThemeIconFill::isDarkSchemeTone(tone) ? ThemeIconFill::saturated(tone).darker(GLYPH_DARKER)
+                                                 : QColor(Qt::white);
+}
+
+QSize glyphSize(const QSize &pixelSize)
+{
+    if (pixelSize.isEmpty()) {
+        return {};
+    }
+    const qreal side = qMin(pixelSize.width(), pixelSize.height());
+    const qreal ringWidth = qMax(1.0, side * RING_WIDTH_RATIO);
+    const qreal discDiameter = side - 2.0 * ringWidth;
+    const int glyphSide = qMax(1, qRound(discDiameter * GLYPH_DIAMETER_RATIO));
+    return QSize(glyphSide, glyphSide);
+}
+
+QPixmap renderBadge(const QByteArray &svg, const QColor &tone, const QSize &pixelSize)
+{
+    if (svg.isEmpty() || !tone.isValid() || pixelSize.isEmpty()) {
+        return {};
+    }
+
+    QPixmap pixmap(pixelSize);
+    pixmap.fill(Qt::transparent);
+
+    const qreal side = qMin(pixelSize.width(), pixelSize.height());
+    const qreal ringWidth = qMax(1.0, side * RING_WIDTH_RATIO);
+    const qreal discDiameter = side - 2.0 * ringWidth;
+
+    QRectF discRect(0, 0, discDiameter, discDiameter);
+    discRect.moveCenter(QRectF(QPointF(0, 0), QSizeF(pixelSize)).center());
+
+    QPainter painter(&pixmap);
+    painter.setRenderHint(QPainter::Antialiasing, true);
+
+    QLinearGradient gradient(discRect.topLeft(), discRect.bottomLeft());
+    const DiscFill fill = discFill(tone);
+    gradient.setColorAt(0.0, fill.top);
+    gradient.setColorAt(1.0, fill.bottom);
+    painter.setPen(Qt::NoPen);
+    painter.setBrush(gradient);
+    painter.drawEllipse(discRect);
+
+    // The ring closes the disc: its outer edge touches the canvas, its inner
+    // edge is the disc boundary, so the two meet without a seam.
+    painter.setBrush(Qt::NoBrush);
+    painter.setPen(QPen(ThemeIconFill::saturated(tone).darker(RING_DARKER), ringWidth));
+    const qreal ringRadius = (side - ringWidth) / 2.0;
+    painter.drawEllipse(discRect.center(), ringRadius, ringRadius);
+
+    const QByteArray glyphSvg = resolveSvgStrokeWidth(
+        resolveSvgColorSentinel(svg, glyphColor(tone).name(QColor::HexRgb).toLatin1()), GLYPH_STROKE_WIDTH);
+    QSvgRenderer renderer(glyphSvg);
+    if (renderer.isValid()) {
+        const QSize size = glyphSize(pixelSize);
+        const QRectF glyphRect(
+            QPointF(discRect.center().x() - size.width() / 2.0, discRect.center().y() - size.height() / 2.0),
+            QSizeF(size));
+        renderer.render(&painter, glyphRect);
+    }
+
+    return pixmap;
+}
+} // namespace ThemeIconBadge