C23 <math.h> Functions

[P3935R0 "Rebasing `` on C23"](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3935r0.html)
proposes pulling the remaining C23 `` functions into C++, since C++26 is based on C23
but `` is still based on C17. The paper puts decimal floating-point out of its own scope,
but nearly everything it lists is an ISO/IEC 60559 operation that
[C23 Annex H](https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf) already requires for
`_Decimal32` / `_Decimal64` / `_Decimal128`. Boost.Decimal should provide all of them regardless
of what C++29 adopts — the paper even notes that `iscanonical` and `canonicalize` are "primarily
motivated by ISO/IEC 60559 decimal floating-point representations."

This issue tracks that surface across all six types (`decimal32_t`, `decimal64_t`, `decimal128_t`,
`decimal_fast32_t`, `decimal_fast64_t`, `decimal_fast128_t`), plus the decimal-only functions from
C23 Annex H that P3935R0 does not cover.

Checked items are already provided; a trailing note gives our current spelling where it differs
from C23.

## Classification and canonicalization

- [x] `issignaling` — provided, documented under "Non-standard Functions"
- [ ] `iscanonical` — C23 specifies exactly which decimal encodings are canonical, so unlike the
binary case this has a hard definition (non-canonical declets in DPD, significands above
the format maximum in BID)
- [ ] `issubnormal`
- [ ] `iszero`
- [ ] `canonicalize`

## Comparison

- [ ] `iseqsig` — `compareSignalingEqual`; raises `FE_INVALID` on quiet NaN, unlike `operator==`
- [ ] `totalorder` — could alias the existing `comparetotal`; see open questions
- [ ] `totalordermag`

## NaN payload

- [ ] `getpayload` — could alias the existing `read_payload`
- [ ] `setpayload`
- [ ] `setpayloadsig`

## Trigonometric (pi-scaled)

- [ ] `acospi`
- [ ] `asinpi`
- [ ] `atanpi`
- [ ] `atan2pi`
- [ ] `cospi`
- [ ] `sinpi`
- [ ] `tanpi`

## Exponential and logarithmic

- [ ] `exp10`
- [ ] `exp10m1`
- [ ] `exp2m1`
- [ ] `log10p1`
- [ ] `logp1` — same value as the existing `log1p`, different C23 spelling
- [ ] `log2p1`

## Power

- [ ] `compoundn` — `(1 + x)^n`;
- [ ] `pown` — `x^n` for integral `n`
- [ ] `powr` — `e^(y * log(x))`, defined only for `x >= 0`
- [ ] `rootn` — `x^(1/n)`
- [ ] `rsqrt` — `1 / sqrt(x)`

## Rounding and integer conversion

- [x] `roundeven` — nearest integer with halfway cases rounded to even
- [ ] `fromfp`
- [ ] `ufromfp`
- [ ] `fromfpx`
- [ ] `ufromfpx`

The `fromfp` family takes a rounding direction from the `FP_INT_*` macros below and a bit width,
and returns NaN when the value is not representable.

## Maximum and minimum

C23 replaced C99's `fmax` / `fmin` NaN behaviour with an IEEE 754-2019 conforming set. The library
currently provides only `fmax` and `fmin`.

- [ ] `fmaximum`
- [ ] `fminimum`
- [ ] `fmaximum_num`
- [ ] `fminimum_num`
- [ ] `fmaximum_mag`
- [ ] `fminimum_mag`
- [ ] `fmaximum_mag_num`
- [ ] `fminimum_mag_num`

Note that for decimal types these are not simply a comparison: when the operands compare equal but
belong to different cohorts, IEEE 754-2019 specifies which member of the cohort is returned.

## Narrowing arithmetic

- [ ] `fadd`
- [ ] `fsub`
- [ ] `fmul`
- [ ] `fdiv`
- [ ] `ffma`
- [ ] `fsqrt`

Narrowing arithmetic: compute in the wider format and round once to the narrower result format.
C23 spells the decimal versions `d32addd64`, `d32addd128`, `d64addd128`, and so on. P3935R0
proposes exposing them in C++ as function templates parameterised on the return type
(`std::fadd(x, y)`) rather than by name suffix; see open questions.

## Decimal-specific (C23 Annex H)

These have no binary counterpart and so are absent from P3935R0, but they belong in any complete
C23 decimal implementation.

- [x] `quantize` — provided as `quantize`
- [x] `samequantum` — provided as `samequantum`
- [x] `quantexp` — provided as `quantexp`
- [x] `encodedec` / `decodedec` — provided as `to_dpd` / `from_dpd`
- [x] `encodebin` / `decodebin` — provided as `to_bid` / `from_bid`
- [ ] `quantum` — returns the quantum of a finite value as a value of the same type
- [ ] `llquantexp` — `quantexp` returning `long long`

## Macros

- [ ] `FP_INT_UPWARD`
- [ ] `FP_INT_DOWNWARD`
- [ ] `FP_INT_TOWARDZERO`
- [ ] `FP_INT_TONEARESTFROMZERO`
- [ ] `FP_INT_TONEAREST`
- [ ] `FP_FAST_*` narrowing-arithmetic hints — C23 spells the decimal analogues
`FP_FAST_D32ADDD64`, `FP_FAST_D32ADDD128`, `FP_FAST_D64ADDD128`, and correspondingly for
`SUB` / `MUL` / `DIV` / `FMA` / `SQRT`

Start with the linked P3935R0 paper and C23 Annex H, then compare the checked and unchecked surface against existing names such as comparetotal, read_payload, log1p, quantize, and the DPD/BID conversion helpers. Resolve the open API questions for all six decimal types, implement the selected functions and macros, and add coverage demonstrating the specified C23 and IEEE 754 behavior.

Written by the indexing model from the issue text.