Explore object pool recycling diagnostics and check timing

[tisonkun]

An object pool needs to decide whether a resource can be reused, while applications may need to understand why it was rejected. Asyncband currently checks idle objects during checkout, discards is_recyclable errors, and retries. Returning an object does not run this check.

We would like to explore:

• Typical uses for recycling diagnostics, such as investigating failed health checks or resets, and whether an optional error sink would help.
• When checks belong at checkout, before return, or in caller code, including discarding an object already known to be broken.
• Whether a separate synchronous check has a concrete benefit. Prefer asynchronous checks for operations such as network pings; a synchronous hook should need a demonstrated use case.

Contributions could start with representative use cases and a small API proposal, informed by other object pools. No breaking change or particular API is assumed by this discussion.

[tisonkun]

Some background for the discussion: rejecting one idle object and failing the caller's acquisition are separate decisions. A pool can discard the object, retry successfully, and still report the rejection reason. An error sink would make that reason available to application diagnostics without making every rejected object an acquisition failure.

Representative cases worth considering:

• A service keeps replacing connections because health checks or session resets fail. Centralized logging or counters could explain the churn even when get() eventually succeeds.
• An object reaches an age or usage limit and is intentionally retired. That is different from a failed ping, even though both decisions may remove the object.
• The borrower already knows that a connection is broken, or needs to reset application state before returning it. Repeating a network check may add no value.

Other pools offer useful reference points:

Pool	Check and failure handling
deadpool 0.13.0	Runs asynchronous recycle during checkout. A manager recycle error discards the object and retries; its details are not surfaced by that path.
bb8 0.9.1	Asynchronous checkout validation failures discard and retry, forwarding the error to an ErrorSink, which defaults to doing nothing. Synchronous has_broken runs on return.
r2d2 0.8.10	This is a synchronous pool. Checkout validation failures go to an error handler before discard and retry. Its return-time has_broken contract requires a quick, nonblocking check.
SQLx 0.9.0	Asynchronous before_acquire and after_release callbacks return Result<bool, Error>. Both Ok(false) and errors reject the connection; errors are logged. This distinguishes an ordinary rejection from a failed check.

The useful interpretation of has_broken is checking locally known state, such as an already observed disconnect. It is not a synchronous substitute for a network ping. Asyncband's existing asynchronous method can also inspect local state without doing I/O; a separate synchronous hook would need a concrete benefit, such as automatic rejection during return, that justifies another public contract.

Check timing depends on the purpose. Checkout validation can detect a connection lost while idle. A reset before return can clean up state while the borrower still owns the object. Callers can already perform asynchronous validation or cleanup explicitly before dropping the wrapper, and use Object::detach to remove a known-bad object from pool management. A successful return-time check cannot guarantee that the object remains healthy after sitting idle, but this does not imply that every workload needs two pings. Automatic asynchronous cleanup on return would also need to account for the fact that Drop itself cannot await.

For Asyncband, a useful first contribution would show where diagnostics inside the manager or explicit caller cleanup fall short. That would help decide whether an optional error sink, clearer usage guidance, or an additional lifecycle operation earns its place, while retaining the existing API during this exploration.