CCI: optional thread-safe broker and parameter access

[markfoodyburton]

Add compile-time option CCI_ENABLE_THREAD_SAFETY (OFF by default) that enables thread-safe access to the CCI broker, parameters, and value pool. When enabled, defines CCI_THREAD_SAFE as a PUBLIC compile definition so all linking code sees it consistently.

Thread-safety changes (all gated by #ifdef CCI_THREAD_SAFE):

Broker (consuming_broker):

• Add shared_mutex to consuming_broker. Read operations (get_preset, get_param_handle, get_unconsumed_presets, etc.) take shared_lock for concurrent access. Write operations (set_preset, lock_preset, add/remove_param, register/unregister callbacks) take unique_lock.

Parameter handles (cci_param_untyped):

• Add recursive_mutex on the param handle list (m_param_handles). Recursive because invalidate_all_param_handles() calls invalidate() which calls remove_param_handle() — re-entrant.

Parameter callbacks (cci_param_typed):

• Change oncall re-entrancy flag to atomic.
• Change fast_read/fast_write optimization flags to atomic.
• Update scoped_true helper to work with atomic.

Value pool (cci_value.cpp):

• Add mutex to impl_pool free list. Cross-thread alloc/dealloc is possible when cci_value objects are stored in broker maps and accessed from different threads.

Build system:

• New option: cmake -DCCI_ENABLE_THREAD_SAFETY=ON
• Try CONFIG mode before Find module for SystemC discovery (fixes -DSystemCLanguage_DIR usage)

Test:

• New ex20_Thread_Safety example demonstrating concurrent broker access from multiple threads using custom originators. Includes performance benchmarks for new-handle and cached-handle workloads. Only built when CCI_ENABLE_THREAD_SAFETY=ON.

Performance (100K ops, -O3, 4 threads vs single-threaded):

• New handle per op: ~133% overhead (dominated by handle registration)
• Cached handle: ~300% overhead (dominated by callback flag contention)
• Realistic usage (handle cached in logger): negligible