Internal - Specialize ConfigParser for declarative configuration parser SPI - #558

TL;DR

Replaces the raw ConfigParser SPI registration used by declarative YAML
config parsers with a dedicated, properly-typed marker interface,
DeclarativeConfigPropertyParser. This removes two @SuppressWarnings
workarounds that existed solely because the SPI type was raw, and allows
dropping the module-wide -Xlint:-processing suppression from the Java
conventions plugin.

Background

ConfigParser<T, R> is a generic conversion interface used across the
config system. The declarative YAML parsers all specialize it to
ConfigParser<DeclarativeConfigProperties, R> for various R, but were
registered for discovery via @AutoService(ConfigParser.class) — i.e.
against the raw generic type rather than a concrete parameterization.

That raw registration had two costs:

• Every implementer needed @SuppressWarnings("rawtypes") to compile
  cleanly under -Xlint:all -Werror.
• The consumer, which loads implementers via
  ServiceLoader.load(ConfigParser.class, ...), got back raw
  ConfigParser instances and had to unchecked-cast each one to
  ConfigParser<DeclarativeConfigProperties, Object> before it could be
  stored in its typed registry map.
• Separately, the annotation-ownership warnings this raw usage produced
  were being blanket-suppressed project-wide via -Xlint:-processing in
  the shared Java conventions plugin, which also silenced any other
  unrelated processing warnings from any module using that convention.

Change

Introduces DeclarativeConfigPropertyParser, an interface that fixes the
generic parameters: ConfigParser<DeclarativeConfigProperties, Object>.
All 11 YAML declarative config parsers (profiling settings, logging,
proxy, SQL query max length, SQL tag databases, stacktrace filters,
tracing mode, transaction naming schemes, transaction settings, trigger
trace, URL sample rate) now implement this interface directly instead of
ConfigParser<DeclarativeConfigProperties, R>, and register via
@AutoService(DeclarativeConfigPropertyParser.class) instead of
@AutoService(ConfigParser.class).

The consumer's ServiceLoader.load(...) call is updated to load
DeclarativeConfigPropertyParser directly, so the loaded instances are
already correctly typed for the registry map — no cast needed.

With the raw-type usage gone, the underlying annotation-ownership warning
no longer fires, so -Xlint:-processing is removed from the shared Java
conventions plugin — tightening lint enforcement for every module built
with that plugin, not just this one.

Why this approach

Rather than suppressing the warnings at each of the 11 call sites (or
leaving the project-wide -Xlint escape hatch in place), narrowing the
SPI contract to a single, correctly-typed interface eliminates the root
cause: the type system now reflects that every implementer of this SPI is
a DeclarativeConfigProperties-to-Object parser, so no raw type or
unchecked cast is ever necessary to satisfy that contract.

Verification

• Full project compileJava passes under -Werror, confirming the
  -Xlint:-processing removal doesn't surface new lint failures anywhere
  else in the build.
• All existing parser unit tests and the declarative config parser test
  suite pass unchanged.
• Confirmed via generated META-INF/services output that all 11 parsers
  are registered under the new SPI type, with none left registered under
  the old one.

No functional or behavioral change — this is purely an SPI-typing and
lint-cleanliness improvement.

Test services data

1. e-1712644058766987264
2. e-1712643928659124224
3. e-1742334541200846848
4. e-1777406072376840192