Add support for CSS gradients

[maitredede]

Implements CSS gradients as background images, as described in #18.

Approach

A new GradientImage : Image (source/resource/gradientimage.{h,cpp}) reuses the
existing gradient plumbing: LinearGradientValues, RadialGradientValues,
GradientStops and SpreadMethod already back the SVG gradients, so linear and
radial need no new cairo code beyond an inner radius on the radial values.

CSSGradientValue deliberately does not cache a resolved image the way
CSSImageValue does. A gradient is style dependent — currentColor and
em/rem lengths differ per element — so the image is built in
BoxStyle::convertImage, which has the computed style at hand.

Gradients report no intrinsic dimensions, so they size to the positioning area
and integrate with background-size, background-position and
background-repeat unchanged. Tiling mirrors SVGImage::drawPattern, using a
recording surface so a tiled gradient stays vectorial in the PDF.

Commits

1. Parse CSS gradient functions — CSSGradientValue, CSSGradientType,
   CSSGradientStop, and consumeImage() accepting all six functions with
   strict grammar validation.
2. Add support for CSS linear gradients — GradientImage, the shared color
   stop machinery, linear and repeating-linear rendering.
3. Add support for CSS radial gradients — both shapes, the four size
   keywords, explicit radii, at <position>; adds RadialGradientValues::r0
   (defaulted, so the SVG path is unaffected).
4. Add support for CSS conic gradients — GraphicsContext::setConicGradient()
   built on cairo_pattern_create_mesh, since cairo has no conic primitive.
   interpolateColor moves to Color.
5. Add a rasterized conic gradient rendering mode — an alternative sampler
   plus the public toggle described below.
6. Accept a gradient with a single color stop — per css-images-4.
7. Document CSS gradient support — CHANGELOG.md and FEATURES.md.

Commits 4 and 5 are kept separate so the rasterized path can be dropped or
cherry-picked independently of the mesh implementation.

Conic gradients and the new setting

Neither cairo nor PDF has a conic shading, so the sweep must be approximated.
Two implementations are provided, selected at runtime:

enum class ConicGradientRendering { Mesh, Raster };
void setConicGradientRendering(ConicGradientRendering rendering);
ConicGradientRendering conicGradientRendering();

with the usual C mirror (plutobook_set_conic_gradient_rendering()), following
the existing process-wide setters such as plutobook_set_http_timeout().

Mesh is the default: a tensor patch mesh cut at every color stop and never
wider than 1/48 turn, which stays vectorial and zooms cleanly. Raster samples
the sweep into a bitmap at the current device scale (capped at 2048²), which is
exact in angle but resolution bound. On a two-conic page the mesh output is
21 kB of /ShadingType 7 with no images, against 37 kB with two embedded images
for the raster path; the two are visually indistinguishable at 96 dpi.

If the raster path is unwanted, dropping commit 5 leaves a working mesh-only
implementation with no public API addition.

Validation

Every case was rendered with tools/html2png and compared against a headless
Chrome screenshot of the same page: 30 linear cases (side and corner keywords,
angles in deg/turn/negative, explicit, implicit and two-position stops,
transition hints, px and em positions, out-of-range and reversed stops,
currentColor, the three repeating variants, and combinations with
background-size/-position/-repeat), 30 radial cases (both shapes, all four
size keywords, explicit radii, at <position>, degenerate zero radius), 20 conic
cases, 23 invalid-syntax cases, and an SVG radialGradient page checking that
the added inner radius causes no regression. All match.

PDF output was checked directly: repeating gradients come out as plain
/ShadingType entries with no embedded images, so CAIRO_EXTEND_REPEAT is
expanded into the PDF function domain and no stop-materialisation workaround is
needed.

Two fidelity notes. Transition hints are flattened into 12 sampled stops, since
cairo has no midpoint concept. Adjacent stops of differing opacity are sampled
the same way, because cairo interpolates stops without premultiplying alpha
while CSS requires premultiplied interpolation — without this,
linear-gradient(rgba(255,0,0,0), blue) ramps through pink instead of
white to blue.

Out of scope and known gaps

• Multiple background layers (Add support for multiple backgrounds #17) — there is still exactly one background image.
• at <position> reuses the existing two-value position parser, so the four-value
  form (at left 10px top 20px) is rejected; the codebase has no four-value
  position parser.
• image(), cross-fade(), element(), and css-images-4 interpolation spaces
  such as in oklch.
• list-style-image: <gradient> renders nothing where Chrome draws a small
  square. A gradient must report no intrinsic dimensions in order to size to the
  positioning area, and a marker box has none, so it collapses to 0×0. It does
  not crash. Fixing it needs default sizing for replaced content, which felt out
  of scope here — happy to address it if you would rather it were handled.

Review follow-ups

Three fixes found while reviewing the branch:

• Handle gradients in generated content — content consumes images through
  consumeImage(), so a gradient could reach the content builder, whose
  dispatch chain ends in an unchecked CSSUnaryFunctionValue cast.
  content: linear-gradient(red, blue) aborted in debug builds and read
  garbage in release ones. It now builds a GradientImage, which paints
  nothing for want of a positioning area but is no longer misinterpreted.
• Clamp conic gradient bounds before narrowing them — the repeating period
  range and the rasterized resolution were converted to int before being
  bounded, which is undefined for a nearly zero period or a very large radius.
• Memoize gradient images on the style — a gradient image was rebuilt on
  every call, once per box per page, and the document heap only reclaims at
  teardown, so a long document accumulated identical images. They are now
  cached on the style that produced them.