Switch LamarServiceDescriptor to factory-shape base ctor

The (Type, Type, ServiceLifetime) base ctor on LamarServiceDescriptor made
the descriptor look like a normal concrete-type registration to external
consumers. Wolverine HTTP code-gen reads that as "I can inline-construct
this" and walks the impl's ctor chain — which fails as
'NotSupportedException: Cannot build service type ... in any way' whenever
a ctor parameter is registered only via Lamar's convention scan (scan-only
deps don't surface to the IServiceCollection snapshot Wolverine reads).

Per Wolverine's docs, an "opaque lambda factory" descriptor with a
Scoped or Transient lifetime makes Wolverine fall back to service location
at runtime — exactly the path we want, since service location goes through
Lamar's IServiceProvider, which can resolve scan-only deps.

Changing the base ctor to (Type, Func, ServiceLifetime) flips the
descriptor's external shape to that opaque-factory form, eliminating the
inline-construction code-gen path entirely. Lamar's own self-discovery is
unaffected — Instance.For checks for the LamarServiceDescriptor subclass
first and returns the typed Instance property, bypassing the
ImplementationFactory branch.

The factory delegate itself throws if invoked: Wolverine service-locates
without calling it, and Lamar's resolution path uses the subclass's Instance
property, so the only way to reach the delegate is via a non-Lamar
IServiceProvider — which is misuse this descriptor isn't designed for.

Verified end-to-end against a Wolverine HTTP endpoint that constructor-
captures IAsyncDocumentSession through a chain of services including
scan-only deps: three concurrent POST requests now succeed with HTTP 200
and distinct session + factory identity hashes (was: same hash and a
Raven 'Concurrent usage of async tasks' exception under the legacy
Lamar bridge, then 'Cannot build service type' under the intermediate
concrete-type-base-ctor fix).

All 714 tests in Lamar.Testing pass on net8.0, net9.0, net10.0.
All 23 tests in Lamar.AspNetCoreTests pass on all three TFMs.

Author: kblooie

src/Lamar/LamarServiceDescriptor.cs

@@ -1,3 +1,4 @@
+using System;
 using Lamar.IoC.Instances;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -15,21 +16,36 @@ namespace Lamar;
 ///     resolved Lamar registrations as singleton fields on generated handler
 ///     classes; see JasperFx/wolverine#1610 and #537 for visible symptoms.
 ///
-///     The subclass routes the Instance through Lamar-specific state, while
-///     delegating to the (Type, Type, ServiceLifetime) base constructor so the
-///     descriptor's surface-area Lifetime is honest. Lamar's own self-discovery
-///     in <see cref="Instance.FindServiceRegistration" /> (and the related
-///     Matches helper) prefers the typed Instance when present and otherwise
-///     reconstructs from the descriptor's ImplementationType / Lifetime — the
-///     two paths produce equivalent results for simple registrations.
+///     Descriptor shape: we delegate to the (Type, Func, ServiceLifetime) base
+///     constructor, which makes the descriptor look like an "opaque lambda
+///     factory" to external consumers. This is the shape Wolverine's docs say
+///     triggers service-location at runtime — exactly what we want, because
+///     service location calls back into Lamar's IServiceProvider, which can
+///     see scan-only deps (whereas Wolverine's inline-construction codegen
+///     cannot). The factory delegate itself is never invoked under Lamar
+///     resolution: Lamar's <see cref="Instance.For" /> checks for the subclass
+///     first and returns the typed Instance directly, bypassing the factory
+///     branch. The factory body throws to make any incorrect direct invocation
+///     loud and obvious.
 /// </summary>
 public sealed class LamarServiceDescriptor : ServiceDescriptor
 {
     public LamarServiceDescriptor(Instance instance)
-        : base(instance.ServiceType, instance.ImplementationType ?? instance.ServiceType, instance.Lifetime)
+        : base(
+            instance.ServiceType,
+            FactoryShouldNotBeInvoked,
+            instance.Lifetime)
     {
         Instance = instance;
     }
 
     public Instance Instance { get; }
+
+    private static object FactoryShouldNotBeInvoked(IServiceProvider sp) =>
+        throw new InvalidOperationException(
+            "LamarServiceDescriptor's ImplementationFactory is a Wolverine/MS-DI codegen marker " +
+            "and should not be invoked directly. Resolution under Lamar goes through Instance.For " +
+            "(which prefers the typed Instance on the subclass) and never through this delegate. " +
+            "If you see this, you are resolving the descriptor outside a Lamar container — build " +
+            "the container via UseLamar(...) instead of stock MS-DI ServiceProvider.");
 }