Breaking change to current_retry_interval (#11203)

## What changed?
- current_retry_interval=nil after dispatch to Matching. Previously we were returning the
predicted next retry interval
- current_retry_interval and next_attempt_schedule_time both nil when paused

Consider an activity that's in retry backoff before attempt 2. This
retry interval is 5s and the next one, if there is another, will be 10s.

`current_retry_interval`:

```
         SCHEDULED       (dispatched to matching)                STARTED                (attempt completed/failed)
before               5s                                 10s                nil
after                5s                                 nil                nil
```

`next_attempt_schedule_time` for comparison:

```
         SCHEDULED       (dispatched to matching at t)           STARTED                (attempt completed/failed)
                     t                                  nil                nil
```


## Why?
I think that the current behavior is a bug.

## How did you test it?
- [x] added new unit test(s)

## Potential risks
Breaking change: someone could be relying on the old behavior


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Intentional breaking change to
DescribeWorkflowExecution/DescribeActivityExecution metadata; clients
that relied on post-dispatch predicted retry intervals will see
different values.
> 
> **Overview**
> **Breaking change:** `current_retry_interval` on pending activities is
no longer a predicted *next* backoff after the retry has been dispatched
to Matching. It is set only while the server is still waiting to
dispatch the retry (`ScheduledTime` in the future and not paused), as
the elapsed time from last attempt completion to that schedule
time—aligned with when `next_attempt_schedule_time` is set.
> 
> Once the backoff elapses and the task is in Matching (or the activity
is **paused**), both `current_retry_interval` and
`next_attempt_schedule_time` are **nil**, including for paused
activities that would still be “backing off” internally.
> 
> Coverage moves to a focused unit test on `GetPendingActivityInfo`, a
workflow-vs-standalone parity suite (`TestParityCurrentRetryInterval`),
removal of the older standalone-only test, and XDC pause/failover
expectations updated to expect nil `CurrentRetryInterval`.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
5676d92. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: dandavison

service/history/workflow/activity.go

@@ -120,17 +120,15 @@ func GetPendingActivityInfo(
 		p.Attempt = ai.Attempt
 		if p.State == enumspb.PENDING_ACTIVITY_STATE_SCHEDULED {
 			scheduledTime := ai.ScheduledTime.AsTime()
-			if now.Before(scheduledTime) {
-				// in this case activity is waiting for a retry
+			if now.Before(scheduledTime) && !ai.Paused {
+				// waiting for the retry to be dispatched to Matching
 				p.NextAttemptScheduleTime = ai.ScheduledTime
 				currentRetryDuration := p.NextAttemptScheduleTime.AsTime().Sub(p.LastAttemptCompleteTime.AsTime())
 				p.CurrentRetryInterval = durationpb.New(currentRetryDuration)
 			} else {
-				// in this case activity is at least scheduled
+				// retry has been dispatched to Matching, or the activity is paused so no dispatch will occur
 				p.NextAttemptScheduleTime = nil
-				// we rely on the fact that ExponentialBackoffAlgorithm is deterministic, and  there's no random jitter
-				interval := backoff.ExponentialBackoffAlgorithm(ai.RetryInitialInterval, ai.RetryBackoffCoefficient, p.Attempt)
-				p.CurrentRetryInterval = durationpb.New(interval)
+				p.CurrentRetryInterval = nil
 			}
 		}
 	}

service/history/workflow/activity_test.go

@@ -294,6 +294,36 @@ func (s *activitySuite) TestGetPendingActivityInfoHasRetryPolicy() {
 	s.Equal(ai.RetryMaximumAttempts, pi.ActivityOptions.RetryPolicy.MaximumAttempts)
 }
 
+func (s *activitySuite) TestGetPendingActivityInfoNextAttemptScheduleTimeAndCurrentRetryInterval() {
+	now := s.mockShard.GetTimeSource().Now().UTC()
+	activityType := commonpb.ActivityType{
+		Name: "activityType",
+	}
+	ai := &persistencespb.ActivityInfo{
+		StartedEventId:          common.EmptyEventID,
+		LastAttemptCompleteTime: timestamppb.New(now),
+		HasRetryPolicy:          true,
+	}
+	s.mockMutableState.EXPECT().GetActivityType(gomock.Any(), gomock.Any()).Return(&activityType, nil).Times(2)
+
+	// Before dispatch to Matching: waiting for the retry, so we report when the next attempt is
+	// scheduled and the interval until then.
+	ai.ScheduledTime = timestamppb.New(now.Add(5 * time.Second))
+	pi, err := GetPendingActivityInfo(context.Background(), s.mockShard, s.mockMutableState, ai)
+	s.NoError(err)
+	s.Equal(enumspb.PENDING_ACTIVITY_STATE_SCHEDULED, pi.State)
+	s.Equal(ai.ScheduledTime, pi.NextAttemptScheduleTime)
+	s.Equal(durationpb.New(5*time.Second), pi.CurrentRetryInterval)
+
+	// After dispatch to Matching: no next attempt schedule time or current retry interval.
+	ai.ScheduledTime = timestamppb.New(now.Add(-1 * time.Minute))
+	pi, err = GetPendingActivityInfo(context.Background(), s.mockShard, s.mockMutableState, ai)
+	s.NoError(err)
+	s.Equal(enumspb.PENDING_ACTIVITY_STATE_SCHEDULED, pi.State)
+	s.Nil(pi.NextAttemptScheduleTime)
+	s.Nil(pi.CurrentRetryInterval)
+}
+
 func (s *activitySuite) AddActivityInfo() *persistencespb.ActivityInfo {
 	activityId := "activity-id"
 	activityScheduledEvent := &historypb.HistoryEvent{