Eliminate spdlog dependency (#773)

Removes the vendored spdlog library (~12,000 lines) and replaces it with a purpose-built logging system in zencore (~1,800 lines). The new implementation provides the same functionality with fewer abstractions, no shared_ptr overhead, and full control over the logging pipeline.

### What changed

**New logging core in zencore/logging/:**
- LogMessage, Formatter, Sink, Logger, Registry - core abstractions matching spdlog's model but simplified
- AnsiColorStdoutSink - ANSI color console output (replaces spdlog stdout_color_sink)
- MsvcSink - OutputDebugString on Windows (replaces spdlog msvc_sink)
- AsyncSink - async logging via BlockingQueue worker thread (replaces spdlog async_logger)
- NullSink, MessageOnlyFormatter - utility types
- Thread-safe timestamp caching in formatters using RwLock

**Moved to zenutil/logging/:**
- FullFormatter - full log formatting with timestamp, logger name, level, source location, multiline alignment
- JsonFormatter - structured JSON log output
- RotatingFileSink - rotating file sink with atomic size tracking

**API changes:**
- Log levels are now an enum (LogLevel) instead of int, eliminating the zen::logging::level namespace
- LoggerRef no longer wraps shared_ptr - it holds a raw pointer with the registry owning lifetime
- Logger error handler is wired through Registry and propagated to all loggers on registration
- Logger::Log() now populates ThreadId on every message

**Cleanup:**
- Deleted thirdparty/spdlog/ entirely (110+ files)
- Deleted full_test_formatter (was ~80% duplicate of FullFormatter)
- Renamed snake_case classes to PascalCase (full_formatter -> FullFormatter, json_formatter -> JsonFormatter, sentry_sink -> SentrySink)
- Removed spdlog from xmake dependency graph

### Build / test impact

- zencore no longer depends on spdlog
- zenutil and zenvfs xmake.lua updated to drop spdlog dep
- zentelemetry xmake.lua updated to drop spdlog dep
- All existing tests pass, no test changes required beyond formatter class renames

1 files changed, 142 insertions, 0 deletions

diff --git a/src/zencore/logging/logger.cpp b/src/zencore/logging/logger.cpp
new file mode 100644
index 000000000..dd1675bb1
--- /dev/null
+++ b/src/zencore/logging/logger.cpp
@@ -0,0 +1,142 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+
+#include <zencore/logging/logger.h>
+#include <zencore/thread.h>
+
+#include <string>
+#include <vector>
+
+namespace zen::logging {
+
+struct Logger::Impl
+{
+	std::string			 m_Name;
+	std::vector<SinkPtr> m_Sinks;
+	ErrorHandler*		 m_ErrorHandler = nullptr;
+};
+
+Logger::Logger(std::string_view InName, SinkPtr InSink) : m_Impl(std::make_unique<Impl>())
+{
+	m_Impl->m_Name = InName;
+	m_Impl->m_Sinks.push_back(std::move(InSink));
+}
+
+Logger::Logger(std::string_view InName, std::span<const SinkPtr> InSinks) : m_Impl(std::make_unique<Impl>())
+{
+	m_Impl->m_Name = InName;
+	m_Impl->m_Sinks.assign(InSinks.begin(), InSinks.end());
+}
+
+Logger::~Logger() = default;
+
+void
+Logger::Log(const LogPoint& Point, fmt::format_args Args)
+{
+	if (!ShouldLog(Point.Level))
+	{
+		return;
+	}
+
+	fmt::basic_memory_buffer<char, 250> Buffer;
+	fmt::vformat_to(fmt::appender(Buffer), Point.FormatString, Args);
+
+	LogMessage LogMsg(Point, m_Impl->m_Name, std::string_view(Buffer.data(), Buffer.size()));
+	LogMsg.SetThreadId(GetCurrentThreadId());
+	SinkIt(LogMsg);
+	FlushIfNeeded(Point.Level);
+}
+
+void
+Logger::SinkIt(const LogMessage& Msg)
+{
+	for (auto& CurrentSink : m_Impl->m_Sinks)
+	{
+		if (CurrentSink->ShouldLog(Msg.GetLevel()))
+		{
+			try
+			{
+				CurrentSink->Log(Msg);
+			}
+			catch (const std::exception& Ex)
+			{
+				if (m_Impl->m_ErrorHandler)
+				{
+					m_Impl->m_ErrorHandler->HandleError(Ex.what());
+				}
+			}
+		}
+	}
+}
+
+void
+Logger::FlushIfNeeded(LogLevel InLevel)
+{
+	if (InLevel >= m_FlushLevel.load(std::memory_order_relaxed))
+	{
+		Flush();
+	}
+}
+
+void
+Logger::Flush()
+{
+	for (auto& CurrentSink : m_Impl->m_Sinks)
+	{
+		try
+		{
+			CurrentSink->Flush();
+		}
+		catch (const std::exception& Ex)
+		{
+			if (m_Impl->m_ErrorHandler)
+			{
+				m_Impl->m_ErrorHandler->HandleError(Ex.what());
+			}
+		}
+	}
+}
+
+void
+Logger::SetSinks(std::vector<SinkPtr> InSinks)
+{
+	m_Impl->m_Sinks = std::move(InSinks);
+}
+
+void
+Logger::AddSink(SinkPtr InSink)
+{
+	m_Impl->m_Sinks.push_back(std::move(InSink));
+}
+
+void
+Logger::SetErrorHandler(ErrorHandler* Handler)
+{
+	m_Impl->m_ErrorHandler = Handler;
+}
+
+void
+Logger::SetFormatter(std::unique_ptr<Formatter> InFormatter)
+{
+	for (auto& CurrentSink : m_Impl->m_Sinks)
+	{
+		CurrentSink->SetFormatter(InFormatter->Clone());
+	}
+}
+
+std::string_view
+Logger::Name() const
+{
+	return m_Impl->m_Name;
+}
+
+Ref<Logger>
+Logger::Clone(std::string_view NewName) const
+{
+	Ref<Logger> Cloned(new Logger(NewName, m_Impl->m_Sinks));
+	Cloned->SetLevel(m_Level.load(std::memory_order_relaxed));
+	Cloned->SetFlushLevel(m_FlushLevel.load(std::memory_order_relaxed));
+	Cloned->SetErrorHandler(m_Impl->m_ErrorHandler);
+	return Cloned;
+}
+
+}  // namespace zen::logging