Adds three public event-data classes for the rewarded-ad reward lifecycle:

- AdRewardEarnedUnverified: fires when the ad SDK reports a user-earned
  reward before server-side verification completes. Carries
  rewardVerificationEnabled, rewardItem (AdMob reward.type), and
  rewardAmount.
- AdRewardVerified: fires when server-side verification confirms the
  reward. Carries rewardType (discriminator) plus optional virtual-currency
  code/amount fields populated only for .virtualCurrency.
- AdRewardFailedToVerify: fires on terminal verification failure. Carries
  a structured failureReason.

All three conform to AdImpressionEventData (mediatorName/adFormat/placement/
adUnitId/impressionId + optional networkName) and follow the existing
AdLoaded/AdRevenue shape: NSObject subclass, @_spi(Experimental),
@objc(RC...) name, Codable, @unchecked Sendable, private(set) properties,
NSObject equality/hash overrides. Optional NSNumber fields use the existing
private rawValue Int? + computed NSNumber? pattern from AdFailedToLoad.

The internal AdEvent enum gains three matching cases and the
creationData/eventData/impressionIdentifier/networkName/mediatorErrorCode
helpers are extended exhaustively. Three new accessors are added for
reward-specific data (rewardEarnedUnverifiedData, rewardVerifiedData,
rewardFailedToVerifyData) for use by the upcoming wire-schema mapping.

EventType cases are added to AdEventsRequest to keep the eventType switch
exhaustive; wire raw values keep the rc_ads_ad_reward_sdk_* prefix to
preserve the cross-platform backend ingestion contract. The full wire-field
mapping lands in a follow-up commit.

Adds three @_spi(Experimental) @objc methods on AdTracker mirroring the
existing trackAdRevenue pattern:

- trackAdRewardEarnedUnverified(_:) — fires when the ad SDK reports a
  user-earned reward before verification.
- trackAdRewardVerified(_:) — fires when verification confirms the reward.
- trackAdRewardFailedToVerify(_:) — fires when verification terminally
  fails.

Each constructs the matching AdEvent case and dispatches to the events
manager via a fire-and-forget Task, exactly like the other track* methods.
This exposes reward-event tracking to apps that don't use the AdMob
adapter; the adapter will route through these in a follow-up commit.

Adds the reward-event wire fields to AdEventsRequest.AdEventRequest:

- rewardVerificationEnabled, rewardItem, rewardAmount (earned/unverified)
- rewardType, rewardCurrencyCode, rewardCurrencyAmount (verified)
- failureReason (failed-to-verify)

The init?(storedEvent:) mapping reads the three new accessors on AdEvent
(rewardEarnedUnverifiedData, rewardVerifiedData, rewardFailedToVerifyData)
introduced in the prior commit, so the fields are populated only for the
matching event type and null for all others. CodingKeys gains entries for
each new field; snake_case conversion turns them into reward_verification_
enabled / reward_item / reward_amount / reward_type / reward_currency_code
/ reward_currency_amount / failure_reason on the wire.

EventType cases for the three reward events were added in the prior commit
to keep that commit's switch exhaustive; this commit completes the wire
schema by adding the corresponding field mapping.

Extends the existing AdEventTests, AdEventsRequestTests, and
PurchasesAdEventsTests files (matching the codebase convention of
one file per category covering all event variants):

- AdEventTests: equality assertions for each new reward type (same /
  different properties), nil-field acceptance for optional reward fields,
  rawValue stability for AdRewardType / AdRewardFailureReason static
  constants, and Codable round-trips for all three reward data classes.
- AdEventsRequestTests: snapshot tests covering the wire JSON payloads
  for the three new reward event types, with the corresponding committed
  snapshot fixtures.
- PurchasesAdEventsTests: integration tests verifying that calling
  Purchases.shared.adTracker.trackAdReward* writes the expected AdEvent
  case into mockEventsManager.trackedAdEvents with all fields preserved.

Snapshot fixtures verify the snake_case wire format produced by the
JSONEncoder.KeyEncodingStrategy.convertToSnakeCase strategy applied
to AdEventsRequest.AdEventRequest. The wire event names retain the
_sdk_ infix (rc_ads_ad_reward_sdk_unverified, etc.) per the
cross-platform backend ingestion contract.

Extends RCAdTrackerAPI to exercise the new reward public surface so
ObjC compatibility breakage is caught by the API tester target in CI.
Covers:

- RCAdRewardType (static constants, raw-value initializer, rawValue property).
- RCAdRewardFailureReason (static constants, raw-value initializer,
  rawValue property).
- RCAdRewardEarnedUnverified (full initializer with NSNumber rewardAmount,
  every public property accessor).
- RCAdRewardVerified (full initializer with NSNumber rewardCurrencyAmount,
  every public property accessor).
- RCAdRewardFailedToVerify (full initializer, every public property accessor).
- AdTracker.trackAdRewardEarnedUnverified / trackAdRewardVerified /
  trackAdRewardFailedToVerify.

Note: the api/*.swiftinterface baselines do not include @_spi(Experimental)
declarations (verified by the existing AdLoaded / AdRevenue / MediatorName
also being absent from the baselines), so the new reward types do not
appear in those files and regeneration produces no diff. The ObjC API
tester is the active compatibility check for this surface.

Fixes CI build failures: pass `nil as Int?` for amount parameters to
pick the Int? overload over NSNumber?, and qualify `AdRewardType.noReward`
to disambiguate from `VerifiedReward.noReward`.

Co-authored-by: Antonio Pallares <ajpallares@users.noreply.github.com>

Replaces the AdRewardType discriminator + flat rewardCurrencyCode/Amount
fields on AdRewardVerified with a single reward: AdReward property that
bundles kind and payload together. AdReward also subsumes the adapter's
VerifiedReward and the internal RevenueCat.VerifiedReward enum, so all
three modules share one type.

- New AdReward struct at @_spi(Experimental) in the main SDK with
  virtualCurrency / noReward / unsupportedReward factories and a
  kindRawValue accessor for wire encoding and ObjC interop.
- Promotes VirtualCurrencyReward from @_spi(Internal) to @_spi(Experimental).
- AdRewardVerified gains custom Codable that preserves the existing
  rewardType / rewardCurrencyCode / rewardCurrencyAmount wire keys, plus
  @objc derived accessors (rewardKindRawValue, virtualCurrencyCode,
  virtualCurrencyAmount) and an ObjC init taking the flat fields.
- Adapter's VerifiedReward struct removed; RewardVerificationResult now
  carries AdReward and exposes it via a renamed `reward` property.

…to public

Consistency with AdReward's .noReward / .unsupportedReward static lets:
external devs now write `if result == .failed` rather than `if result.isFailed`,
using the same equality idiom they already use for AdReward cases.

`.failed` is a parameter-less singleton with no provenance to forge, so
promoting it to `public` introduces no construction-safety concern.

… reward

The previous example called AdReward.virtualCurrency(code:amount:), which is
internal — SPI consumers cannot construct it. Show the realistic flow where
the AdReward comes from the reward-verification pipeline.

AdRewardEarnedUnverified, AdRewardVerified, and AdRewardFailedToVerify are
value types whose stored properties are all Sendable lets. Plain Sendable
turns on the compiler check we were opting out of for no reason — the
@unchecked was a copy-paste from the @objc NSObject-backed event classes.

Both are final NSObject subclasses with only let properties, so they're
trivially Sendable-safe. Declaring @unchecked Sendable on them lets the
reward event structs that hold them use checked Sendable instead of
@unchecked, closing the diagnostic warning surfaced by the previous commit.

When AdRewardVerified's decoder hits an unknown reward kind or a malformed
virtual_currency payload, it correctly falls back to .unsupportedReward
without crashing — but until now it did so silently, hiding backend/SDK
schema drift. Add two AdsStrings warnings and emit them on the fallback
paths, plus three tests covering unknown kind, missing amount, and
non-positive amount.

…a protocol

Both accessors previously enumerated every case; all non-failedToLoad data
types already conform to AdImpressionEventData, so a single cast on the
existing eventData reads both fields. Future ad-event cases that conform
to AdImpressionEventData get covered automatically.

The previous one-liners ('Data for ad reward earned (unverified) events.')
repeated the type name. Replace with descriptions that explain what moment
the event represents, mirroring the case-level docs on AdEvent.

Swiftlint flags the previous AdEventTests body as over the type_body_length
limit even before this PR. Move the three new decoder-fallback tests into
an extension on AdEventTests, and consolidate the JSON construction into a
shared helper so each test reads as a one-line behavioural assertion.

Adds parameterized `encode<K:CodingKey>(into:typeKey:codeKey:amountKey:)`
and `decode<K:CodingKey>(from:typeKey:codeKey:amountKey:)` helpers on
AdReward, and has AdRewardVerified delegate to them. The wire layout
(rewardType / rewardCurrencyCode / rewardCurrencyAmount) is unchanged.

Adding a new AdReward.Kind now only requires editing AdReward (factory,
Kind raw value, decode branch) — AdRewardVerified stays untouched unless
the new kind introduces new wire fields.

…ward

…gle validation point

Routes AdReward.virtualCurrency(code:amount:), AdReward.decode, and
RewardVerificationStatusResponse through VirtualCurrencyReward.init?(code:amount:),
which rejects empty code or non-positive amount. Drops the now-redundant
AdsStrings.invalid_virtual_currency_amount.

… test

Moves AdRewardFailureReason and the three AdReward* event structs out of
AdEvent.swift into a new file, and registers it in the Xcode project. The
file_length disable on AdEvent.swift stays since the remainder is still
above the 400-line limit.