feat: modify Downloader config through Blobs builder (n0-computer#75)

## Description
A fix for n0-computer#74 , allowing
users of the Blobs protocol to once again provide configuration for the
internally-used Downloader struct - both concurrency and retry options.
This PR exposes them through the Blobs Builder struct.

## Notes & open questions
I haven't added tests, but this seems to work fine. I probably need
tests for these methods to be a good OSS citizen ;)

## Change checklist

- [x] Self-review.
- [x] Documentation updates following the [style
guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text),
if relevant.
- [ ] Tests if relevant.
- [x] All breaking changes documented.

Author: arilotter

src/net_protocol.rs

@@ -18,7 +18,7 @@ use serde::{Deserialize, Serialize};
 use tracing::debug;
 
 use crate::{
-    downloader::Downloader,
+    downloader::{ConcurrencyLimits, Downloader, RetryConfig},
     provider::EventSender,
     store::GcConfig,
     util::{
@@ -148,6 +148,8 @@ pub struct Builder<S> {
     store: S,
     events: Option<EventSender>,
     rt: Option<LocalPoolHandle>,
+    concurrency_limits: Option<ConcurrencyLimits>,
+    retry_config: Option<RetryConfig>,
 }
 
 impl<S: crate::store::Store> Builder<S> {
@@ -157,20 +159,38 @@ impl<S: crate::store::Store> Builder<S> {
         self
     }
 
-    /// Set a custom `LocalPoolHandle` to use.
+    /// Set a custom [`LocalPoolHandle`] to use.
     pub fn local_pool(mut self, rt: LocalPoolHandle) -> Self {
         self.rt = Some(rt);
         self
     }
 
+    /// Set custom [`ConcurrencyLimits`] to use.
+    pub fn concurrency_limits(mut self, concurrency_limits: ConcurrencyLimits) -> Self {
+        self.concurrency_limits = Some(concurrency_limits);
+        self
+    }
+
+    /// Set a custom [`RetryConfig`] to use.
+    pub fn retry_config(mut self, retry_config: RetryConfig) -> Self {
+        self.retry_config = Some(retry_config);
+        self
+    }
+
     /// Build the Blobs protocol handler.
     /// You need to provide a the endpoint.
     pub fn build(self, endpoint: &Endpoint) -> Blobs<S> {
         let rt = self
             .rt
             .map(Rt::Handle)
             .unwrap_or_else(|| Rt::Owned(LocalPool::default()));
-        let downloader = Downloader::new(self.store.clone(), endpoint.clone(), rt.clone());
+        let downloader = Downloader::with_config(
+            self.store.clone(),
+            endpoint.clone(),
+            rt.clone(),
+            self.concurrency_limits.unwrap_or_default(),
+            self.retry_config.unwrap_or_default(),
+        );
         Blobs::new(
             self.store,
             rt,
@@ -188,6 +208,8 @@ impl<S> Blobs<S> {
             store,
             events: None,
             rt: None,
+            concurrency_limits: None,
+            retry_config: None,
         }
     }
 }