Move rate-limit-manager to messaging client layer

[stubbsta]

Moves rate_limit_manager out of the reliable-channels layer into the
messaging layer, so it sits next to the send pipeline and (in follow-up
work) can interact directly with the RLN component. Three commits, each
reviewable on its own:

1. Drop the rate-limit stage from the reliable channel pipeline

The outgoing pipeline collapses to segmentation → sds → encryption → dispatch. Since the rate-limit hop was the only reason encrypt and
dispatch were decoupled through the event bus, the encrypt-and-dispatch
tail of onReadyToSend folds back into send(), and with it goes all
the machinery that existed only to bridge that hop:

• the rateLimit field and rateConfig constructor param on
  ReliableChannel (and all call sites, incl. the channel manager),
• the ReadyToSendEvent listener and the event type (no other producer),
• the awaitingDispatch accounting,
• enqueueToSend on the manager.

reliable_channel.nim is −191 lines net; the channels layer no longer
references rate limiting at all.

2. Relocate the module to logos_delivery/messaging/rate_limit_manager/

The move doubles as the layering proof: to compile in its new home the
manager loses channelId, the SdsChannelID type, the SDS import, and
brokerCtx — all channels-layer concerns. Rate limiting is a node-wide
property of the sender's RLN identity, not a per-channel one, so nothing
above needs the channel identity back.

The event-emission API is replaced with a direct call:

proc admit(self: RateLimitManager, msg: seq[byte]):
  Future[Result[void, RateLimitError]]

The epoch fields (epochPeriodSec, currentEpochStart,
sentInCurrentEpoch, queue, dequeueReady, resetEpoch) are kept
as-is: this PR changes the component's home and API surface, not the
epoch mechanism.

3. Meter SendService transmissions through the manager

MessagingClientConf gains a rateLimit: RateLimitConfig field
(defaults: DefaultEpochPeriodSec / DefaultMessagesPerEpoch, carried
as a field default so every construction site inherits it).
MessagingClient.new constructs the manager and hands it to
SendService, which consults admit() before the first
transmission of a task — in send() and in the retry loop, guarded by
firstPropagatedTime.isNone() so re-publishes of an already-propagated
message (identical bytes) skip admission. An over-budget task parks in
the task cache as NextRoundRetry; the 1s service loop re-admits it as
the epoch rolls over.

Metering at the transmission stage rather than at MessagingClient.send
is deliberate:

• SDS repair rebroadcasts (dispatchRepair, which documents "Pacing is
  done by SDS itself") dispatch through the same MessagingSend broker
  as user sends. An API-entry gate would let the messaging limiter
  reject repair traffic — exactly when the reliability layer is
  recovering from loss. At the transmission stage, SDS decides that a
  repair is needed and the scheduler decides when it fits the budget.
• Admission is per WakuMessage (one DeliveryTask each), which matches
  RLN accounting: every SDS segment is a separate relay message needing
  its own proof.
• Parking over-budget messages until the epoch rolls requires a retry
  loop; SendService already is one.

Behaviour

Unchanged. admit() is a pass-through skeleton (return ok()), and the
config default leaves enabled: false. This PR is the relocation and
the seam; enforcement lands separately (see below).

Not touched

• The send processors (relay/lightpush) and the RLN proof provider
  registration.
• The epoch/budget mechanism inside the manager.
• ReliableChannelManagerConf still carries rateLimitEnabled /
  rateLimitEpochPeriodSec / rateLimitMessagesPerEpoch. Post-move
  nothing reads them, but tests/api/test_conf.nim exercises them via
  channelsOverrides JSON, so removing them is a follow-up API decision.

Tests

• tests/messaging/test_rate_limit_manager.nim (new) pins the current
  contract: disabled admission is a pass-through, and — explicitly
  documented in the test — enabled admission is too, flipping red when
  real enforcement lands.
• tests/channels/test_reliable_channel_send_receive.nim updated for
  the dropped constructor param; the e2e roundtrips are unchanged.

Follow-up

Per-epoch budgeting, RLN proof attach at the transmission stage, and
RLN-rejection handling in the retry loop are already staged on
feat/rate-limit-enforcement (stacked on this branch, targets #3855).
Quota initialization/persistence is #3838.

🤖 Generated with Claude Code

Issue

closes #3953

[github-actions]

You can find the image built from this PR at

quay.io/wakuorg/nwaku-pr:4021

Built from 07c79ef

[Ivansete-status]

Great movement! Thanks! 🙌

[Ivansete-status]

Suggested change

	## segmentation -> sds -> encryption -> dispatch.
	## segmentation -> sds -> encryption -> rate_limit_manager.