`NotificationChannelDataPropertyCache.GetProperties` is read for every payload on the
publish path (`NotificationChannelDataResolver` and `NotificationChannelDataSerializer`),
but it guarded the whole lookup with one process wide lock, so every cache hit queued
behind the lock and the first reflection plus `Expression.Compile()` for one payload type
blocked all the others. Types that have nothing to do with each other were serialized on
a single lock.
- replace the `Dictionary` plus `SyncLock` pair with a `ConcurrentDictionary<Type,
Lazy<NotificationChannelDataProperty[]>>`, so the hit path takes no lock and building
one type no longer blocks reads of another
- `Lazy<T>` keeps the build at most once: `GetOrAdd` may invoke its factory more than once
under contention, but only one instance is stored and returned, and
`LazyThreadSafetyMode.ExecutionAndPublication` makes the other threads wait for it
- move the reflection and the expression compiling behind the `Lazy` factory so they never
run while a lock is held
- extract the population into `CreateProperties`; the selector, the attribute driven key
resolution and the compiled getters/setters are unchanged, as is the returned array
(callers only enumerate it)
Tests: the cache had no concurrency coverage, which is the property this change rests on.
Add `Should_Build_Property_Metadata_Once_Under_Concurrency`, which reads five payload types
from 320 parallel calls and asserts every call observed the very same metadata instance, and
`Should_Return_Same_Instance_On_Repeated_Calls`.