[nexus] Access DB via "connection", not "pool"

[smklein]

This is a gnarly implementation detail that arose out of a poor decision I made back in async-bb8-diesel.

In async-bb8-diesel, we define a trait named AsyncConnection, which allows callers to execute a variety of asynchronous Diesel operations. This trait is implemented for both the connection pool itself, as well as individual connections.

This was intended for developer convenience -- if you wanted to use a "pool" object directly to issue operations, you could. If you wanted to use a "connection" object to issue operations, you could check it out of the pool and use that too.

This approach has a couple of downsides:

• Generics. This hits build times, causes more codegen, etc. We should use only one implementation.
• Worse errors. Since acting on a "pool" can return a PoolError (e.g., did you fail to check out a connection?) in addition to the diesel errors (e.g. did your query fail?) it forces callers to also be generic over the type of error being used.

This can culminate in code like the following:

omicron/nexus/db-queries/src/db/datastore/service.rs

Lines 47 to 55 in 46ffb37

	pub(crate) async fn service_upsert_conn<ConnError>(
	&self,
	conn: &(impl AsyncConnection<DbConnection, ConnError> + Sync),
	service: Service,
	) -> CreateResult<Service>
	where
	ConnError: From<diesel::result::Error> + Send + 'static,
	PoolError: From<ConnError>,
	{

If we universally just "checked out connections before using them", that code could be written as:

    pub(crate) async fn service_upsert_conn(
        &self,
        conn: ConcreteConnectionType,
        service: Service,
    ) -> CreateResult<Service> {

(and hey, look, that has no generics, will be faster to compile, and will be easier to reason about!)