Migrate ViewModels to CommunityToolkit.MVVM and wire UnitConverter to native engine

## CommunityToolkit.MVVM Migration
- Add CommunityToolkit.Mvvm 8.4.2, set LangVersion 13.0
- All 18 ViewModel classes inherit ObservableObject
- Simple properties use [ObservableProperty] field-based source generator
- Complex properties (side-effect setters) use SetProperty/OnPropertyChanged
- Custom RelayCommand.cs removed, toolkit RelayCommand<object> used
- DelegateCommand.cs preserved (used by Calculator UI project)
- 3 VMs with OnPropertyChanged hooks use HandlePropertySideEffects + override
- All MVVMTK0034/CS0169/CS0219/CS0414 warnings fixed

## UnitConverter Wired to Native CalcManager Engine
- UnitConverterDataLoader extends ConverterDataLoaderBase with all 12
  categories, 168 unit IDs, and conversion ratios matching C++ main
- CurrencyDataLoader fully ported: JSON parsing, cache/web loading,
  pairwise ratio computation, currency symbols, timestamps
- IDL methods marked overridable for C# subclassing
- ConverterDataLoaderBridge updated to use IOverrides interface pattern
- Full OnPropertyChanged side-effect chain: CurrentCategory, Unit1/2,
  Value1/2, Value1Active/2Active, SupplementaryResults, CurrencySymbols
- PopulateData, ResetCategory, SetSelectedUnits, BuildUnitList
- SaveUserPreferences/RestoreUserPreferences via LocalSettings
- Proper OnPaste with negate tracking and DisplayPasteError
- OnCopyCommand copies unlocalized value (matches C++ behavior)
- AnnounceConversionResult uses correct unit order based on active field
- RefreshSupplementaryResults includes first whimsical unit
- ResetView calls model Reset + OnCategoryChanged
- Callbacks marshaled to UI thread via CoreDispatcher
- ButtonPressed alias for CalculatorButton {Binding} compatibility

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Rudy Huyn

src/CalcManager.Interop/UnitConverterImpl.cpp

@@ -16,12 +16,12 @@ namespace winrt::CalcManager::Interop::implementation
 
     void ConverterDataLoaderBridge::LoadData()
     {
-        m_receiver.LoadData();
+        m_receiver.as<CalcManager::Interop::IConverterDataLoaderBaseOverrides>().LoadData();
     }
 
     std::vector<UnitConversionManager::Category> ConverterDataLoaderBridge::GetOrderedCategories()
     {
-        auto categories = m_receiver.GetOrderedCategories();
+        auto categories = m_receiver.as<CalcManager::Interop::IConverterDataLoaderBaseOverrides>().GetOrderedCategories();
         std::vector<UnitConversionManager::Category> result;
         result.reserve(categories.size());
         for (auto const& cat : categories)
@@ -33,7 +33,7 @@ namespace winrt::CalcManager::Interop::implementation
 
     std::vector<UnitConversionManager::Unit> ConverterDataLoaderBridge::GetOrderedUnits(const UnitConversionManager::Category& c)
     {
-        auto units = m_receiver.GetOrderedUnits(ToWinRTCategory(c));
+        auto units = m_receiver.as<CalcManager::Interop::IConverterDataLoaderBaseOverrides>().GetOrderedUnits(ToWinRTCategory(c));
         std::vector<UnitConversionManager::Unit> result;
         result.reserve(units.size());
         for (auto const& u : units)
@@ -46,7 +46,7 @@ namespace winrt::CalcManager::Interop::implementation
     std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash>
     ConverterDataLoaderBridge::LoadOrderedRatios(const UnitConversionManager::Unit& u)
     {
-        auto entries = m_receiver.LoadOrderedRatios(ToWinRTUnit(u));
+        auto entries = m_receiver.as<CalcManager::Interop::IConverterDataLoaderBaseOverrides>().LoadOrderedRatios(ToWinRTUnit(u));
         std::unordered_map<UnitConversionManager::Unit, UnitConversionManager::ConversionData, UnitConversionManager::UnitHash> result;
         for (auto const& entry : entries)
         {
@@ -59,7 +59,7 @@ namespace winrt::CalcManager::Interop::implementation
 
     bool ConverterDataLoaderBridge::SupportsCategory(const UnitConversionManager::Category& target)
     {
-        return m_receiver.SupportsCategory(ToWinRTCategory(target));
+        return m_receiver.as<CalcManager::Interop::IConverterDataLoaderBaseOverrides>().SupportsCategory(ToWinRTCategory(target));
     }
 
     // ---- UnitConverterVMCallbackBridge ----
@@ -72,7 +72,7 @@ namespace winrt::CalcManager::Interop::implementation
 
     void UnitConverterVMCallbackBridge::DisplayCallback(const std::wstring& from, const std::wstring& to)
     {
-        m_receiver.DisplayCallback(hstring(from), hstring(to));
+        m_receiver.as<CalcManager::Interop::IUnitConverterVMCallbackBaseOverrides>().DisplayCallback(hstring(from), hstring(to));
     }
 
     void UnitConverterVMCallbackBridge::SuggestedValueCallback(
@@ -87,12 +87,12 @@ namespace winrt::CalcManager::Interop::implementation
             sv.Unit = ToWinRTUnit(unit);
             winrtValues.push_back(std::move(sv));
         }
-        m_receiver.SuggestedValueCallback(com_array<CalcManager::Interop::SuggestedValueWrapper>(std::move(winrtValues)));
+        m_receiver.as<CalcManager::Interop::IUnitConverterVMCallbackBaseOverrides>().SuggestedValueCallback(com_array<CalcManager::Interop::SuggestedValueWrapper>(std::move(winrtValues)));
     }
 
     void UnitConverterVMCallbackBridge::MaxDigitsReached()
     {
-        m_receiver.MaxDigitsReached();
+        m_receiver.as<CalcManager::Interop::IUnitConverterVMCallbackBaseOverrides>().MaxDigitsReached();
     }
 
     // ---- ViewModelCurrencyCallbackBridge ----
@@ -105,27 +105,27 @@ namespace winrt::CalcManager::Interop::implementation
 
     void ViewModelCurrencyCallbackBridge::CurrencyDataLoadFinished(bool didLoad)
     {
-        m_receiver.CurrencyDataLoadFinished(didLoad);
+        m_receiver.as<CalcManager::Interop::IViewModelCurrencyCallbackBaseOverrides>().CurrencyDataLoadFinished(didLoad);
     }
 
     void ViewModelCurrencyCallbackBridge::CurrencySymbolsCallback(const std::wstring& fromSymbol, const std::wstring& toSymbol)
     {
-        m_receiver.CurrencySymbolsCallback(hstring(fromSymbol), hstring(toSymbol));
+        m_receiver.as<CalcManager::Interop::IViewModelCurrencyCallbackBaseOverrides>().CurrencySymbolsCallback(hstring(fromSymbol), hstring(toSymbol));
     }
 
     void ViewModelCurrencyCallbackBridge::CurrencyRatiosCallback(const std::wstring& ratioEquality, const std::wstring& accRatioEquality)
     {
-        m_receiver.CurrencyRatiosCallback(hstring(ratioEquality), hstring(accRatioEquality));
+        m_receiver.as<CalcManager::Interop::IViewModelCurrencyCallbackBaseOverrides>().CurrencyRatiosCallback(hstring(ratioEquality), hstring(accRatioEquality));
     }
 
     void ViewModelCurrencyCallbackBridge::CurrencyTimestampCallback(const std::wstring& timestamp, bool isWeekOldData)
     {
-        m_receiver.CurrencyTimestampCallback(hstring(timestamp), isWeekOldData);
+        m_receiver.as<CalcManager::Interop::IViewModelCurrencyCallbackBaseOverrides>().CurrencyTimestampCallback(hstring(timestamp), isWeekOldData);
     }
 
     void ViewModelCurrencyCallbackBridge::NetworkBehaviorChanged(int newBehavior)
     {
-        m_receiver.NetworkBehaviorChanged(newBehavior);
+        m_receiver.as<CalcManager::Interop::IViewModelCurrencyCallbackBaseOverrides>().NetworkBehaviorChanged(newBehavior);
     }
 
     // ---- UnitConverterWrapper ----

src/CalcManager.Interop/UnitConverterInterop.idl

@@ -73,29 +73,29 @@ namespace CalcManager.Interop
     unsealed runtimeclass UnitConverterVMCallbackBase
     {
         UnitConverterVMCallbackBase();
-        void DisplayCallback(String fromValue, String toValue);
-        void SuggestedValueCallback(SuggestedValueWrapper[] suggestedValues);
-        void MaxDigitsReached();
+        overridable void DisplayCallback(String fromValue, String toValue);
+        overridable void SuggestedValueCallback(SuggestedValueWrapper[] suggestedValues);
+        overridable void MaxDigitsReached();
     };
 
     unsealed runtimeclass ViewModelCurrencyCallbackBase
     {
         ViewModelCurrencyCallbackBase();
-        void CurrencyDataLoadFinished(Boolean didLoad);
-        void CurrencySymbolsCallback(String fromSymbol, String toSymbol);
-        void CurrencyRatiosCallback(String ratioEquality, String accRatioEquality);
-        void CurrencyTimestampCallback(String timestamp, Boolean isWeekOldData);
-        void NetworkBehaviorChanged(Int32 newBehavior);
+        overridable void CurrencyDataLoadFinished(Boolean didLoad);
+        overridable void CurrencySymbolsCallback(String fromSymbol, String toSymbol);
+        overridable void CurrencyRatiosCallback(String ratioEquality, String accRatioEquality);
+        overridable void CurrencyTimestampCallback(String timestamp, Boolean isWeekOldData);
+        overridable void NetworkBehaviorChanged(Int32 newBehavior);
     };
 
     unsealed runtimeclass ConverterDataLoaderBase
     {
         ConverterDataLoaderBase();
-        void LoadData();
-        CategoryWrapper[] GetOrderedCategories();
-        UnitWrapper[] GetOrderedUnits(CategoryWrapper category);
-        UnitConversionEntry[] LoadOrderedRatios(UnitWrapper unit);
-        Boolean SupportsCategory(CategoryWrapper target);
+        overridable void LoadData();
+        overridable CategoryWrapper[] GetOrderedCategories();
+        overridable UnitWrapper[] GetOrderedUnits(CategoryWrapper category);
+        overridable UnitConversionEntry[] LoadOrderedRatios(UnitWrapper unit);
+        overridable Boolean SupportsCategory(CategoryWrapper target);
     };
 
     runtimeclass UnitConverterWrapper