fix(retry): drop public Javadoc links to package-private Retry; strip prior interceptor from network chain too; correct backoff range docs

Address Copilot review (PR #1701, review 4247997916):

- BaseS3Client.setMaxRetries and MinioAsyncClient.Builder.maxRetries
  Javadocs no longer reference {@link Retry#MAX_RETRY}. The Retry class
  is package-private, so the link target was unresolvable from generated
  public docs. Replaced with the literal default {@code 10}, which is
  what callers actually see.
- BaseS3Client.wrapWithRetry now also strips any prior RetryInterceptor
  from networkInterceptors(), not only the application-interceptor list.
  Previously the Javadoc claimed every prior RetryInterceptor was
  replaced, but only application interceptors were. A caller that had
  (mis)registered RetryInterceptor as a network interceptor would have
  ended up with two retry layers. Defends against that and brings the
  Javadoc claim into line with the code.
- Retry.exponentialBackoffMs Javadoc previously stated the result range
  as [0, sleep]. The actual range is [1, sleep] because nextDouble() is
  in [0.0, 1.0) and the (long) cast truncates rand * sleep to at most
  sleep - 1, so the subtraction never reaches sleep itself. minio-go
  has the same off-by-one (Float64() is also [0.0, 1.0)); this is
  documented now rather than papered over, so callers reading the
  formula see the same bounds the implementation produces.

Validated locally on Java 17:
- :api:check (compile + spotless + spotbugs + tests) PASS
- :api:javadoc PASS

Author: allanrogerr

api/src/main/java/io/minio/BaseS3Client.java

@@ -137,8 +137,10 @@ protected BaseS3Client(BaseS3Client client) {
 
   /**
    * Re-wires the retry interceptor on {@code client} so it reads {@link #maxRetries} from this
-   * instance. Strips any prior {@link Http.RetryInterceptor} (e.g. one bound to a different
-   * instance via the copy constructor) before installing this one.
+   * instance. Strips any prior {@link Http.RetryInterceptor} from BOTH the application-interceptor
+   * and network-interceptor chains (e.g. one bound to a different instance via the copy
+   * constructor, or accidentally registered on the network chain) before installing this one as an
+   * application interceptor.
    *
    * <p>Also forces {@code retryOnConnectionFailure(false)} on the underlying client. The SDK's own
    * {@link Http.RetryInterceptor} is the single source of retry policy; layering OkHttp's
@@ -149,12 +151,13 @@ protected BaseS3Client(BaseS3Client client) {
   private OkHttpClient wrapWithRetry(OkHttpClient client) {
     OkHttpClient.Builder builder = client.newBuilder().retryOnConnectionFailure(false);
     builder.interceptors().removeIf(i -> i instanceof Http.RetryInterceptor);
+    builder.networkInterceptors().removeIf(i -> i instanceof Http.RetryInterceptor);
     return builder.addInterceptor(new Http.RetryInterceptor(() -> this.maxRetries)).build();
   }
 
   /**
    * Sets the maximum number of attempts for transient HTTP failures. Pass {@code 1} to disable
-   * automatic retries. Defaults to {@link Retry#MAX_RETRY}.
+   * automatic retries. Defaults to {@code 10}.
    *
    * @param maxRetries maximum attempts (must be {@code >= 1}).
    */

api/src/main/java/io/minio/MinioAsyncClient.java

@@ -210,7 +210,8 @@ public Builder credentialsProvider(Provider provider) {
      * Supplies a custom {@link OkHttpClient}. The SDK wraps this client to install {@link
      * Http.RetryInterceptor} and forces {@code retryOnConnectionFailure(false)} so that {@link
      * Http.RetryInterceptor} owns the entire retry policy. Any prior {@code RetryInterceptor} on
-     * the supplied client is replaced.
+     * either the application-interceptor or network-interceptor chain of the supplied client is
+     * stripped before the new one is installed (as an application interceptor).
      */
     public Builder httpClient(OkHttpClient httpClient) {
       Utils.validateNotNull(httpClient, "http client");
@@ -231,7 +232,7 @@ public Builder httpClient(OkHttpClient httpClient, boolean close) {
 
     /**
      * Sets the maximum number of attempts per request. Pass {@code 1} to disable automatic retries.
-     * Defaults to {@link Retry#MAX_RETRY}.
+     * Defaults to {@code 10}.
      */
     public Builder maxRetries(int maxRetries) {
       if (maxRetries < 1) throw new IllegalArgumentException("maxRetries must be >= 1");

api/src/main/java/io/minio/Retry.java

@@ -114,11 +114,15 @@ static boolean isRequestErrorRetryable(IOException e) {
    *
    * <pre>
    *   sleep = min(DEFAULT_RETRY_CAP_MS, DEFAULT_RETRY_UNIT_MS * 2^attempt)
-   *   sleep -= random.nextDouble() * sleep * MAX_JITTER     // full jitter when MAX_JITTER == 1.0
+   *   sleep -= (long)(random.nextDouble() * sleep * MAX_JITTER)   // full jitter when MAX_JITTER == 1.0
    * </pre>
    *
-   * <p>With {@code MAX_JITTER == 1.0}, returns a uniform random value in {@code [0, min(cap, base *
-   * 2^attempt)]}.
+   * <p>With {@code MAX_JITTER == 1.0}, returns a value in {@code [1, min(cap, base * 2^attempt)]}.
+   * The lower bound is {@code 1} rather than {@code 0} because {@link
+   * java.util.concurrent.ThreadLocalRandom#nextDouble()} is in {@code [0.0, 1.0)} and the {@code
+   * (long)} cast truncates {@code rand * sleep} to at most {@code sleep - 1}. This matches the
+   * behaviour of minio-go's {@code exponentialBackoffWait}, which uses the same formula and
+   * therefore the same bounds.
    */
   static long exponentialBackoffMs(int attempt) {
     int exp = Math.min(Math.max(attempt, 0), 30);