HurwitzZeta and Zeta(s, a) at the engine's precision for real arguments; Part of #340

[enumeratio]

Part of #340

HurwitzZeta(s, a) and Zeta(s, a) answered at machine precision whatever ce.precision was. For real s and a they now follow it, through a BigDecimal Euler–Maclaurin kernel in the same idiom as bigZeta. Left of Re(s) = 0 the kernel raises its working precision by the cancellation it expects. Past a 1,200-digit budget it falls back to the double kernel. The exact forms and Zeta(s, 1) → bigZeta are unchanged. Complex operands stay at machine precision.

Checked against mpmath (dps 90) over s ∈ [−10, 20] and a ∈ (−10, 10], at precision 30 and 50: worst relative error 5e-29 and 9e-49. About 0.6 ms a call at precision 50.

[arnog]

Thanks, merged, with a review pass on your branch as `f6075589. The main corrections:

• The Euler–Maclaurin plan sized an absolute error and capped the retry at twice the requested digits, so a tiny result was wrong with every digit shown: HurwitzZeta(200, 10) at precision 50 was $5.5 \times 10^{−201}$ (true $1.0 \times 10^{−200}$). The target is now relative to the result's magnitude, with up to four passes, and only a result carrying the requested digits is returned.
• The cancellation allowance did not subtract the result's own magnitude, so HurwitzZeta(-400.5, 0.3) fell back to the double kernel and gave $+\infty$; it now gives the correct 50 digits, and past the kernel's limit the application stays symbolic.
• A Pochhammer factor that rounds to zero as a double was treated as exact termination ($s = -2 + 1e-30$ lost digits from the 30th place); an exact rational $a$ was rounded before the guard digits (HurwitzZeta(3, 1/3) had a wrong last digit on the evaluate route); a large negative base point allocated one BigDecimal per unit of $|a|$ (Zeta(2, -1e8)); all fixed.
• The coefficients reuse the engine's cached Bernoulli table with a running factorial: the first HurwitzZeta(3, 1/3) at precision 1000 went from about 11 s to 0.55 s.

Two open notes in ROADMAP: .N() rounds an exact rational operand to the engine precision before a kernel adds guard digits (engine-wide, not this PR), and the double kernel's small inaccuracies at machine precision.