Implement Service Refactoring

<UserStory> 1950: Implement Service Refactorings </UserStory>

UserStory #1950

<Changes>

1. Added `DataStoreLockGuard` integration in `PaymentManagementService` methods (`sendPaymentReminders`, `generateInvoice`, `getInvoices`, `completePayment`, `getAllInvoices`, `confirmPayment`) to ensure thread-safe access to the datastore.

2. Implemented record enrichment logic in `DataStore::getInvoices()` to automatically link `Invoice` objects with their corresponding `ServiceBooking` and `InventoryItem` entities during loading, validating relationships and throwing exceptions for invalid references.

3. Refactored invoice persistence by implementing `saveInvoices()` using `saveRecords<Invoice, SerializedInvoice>` to write tracked records directly to shared memory.

4. Updated invoice creation and modification flows:
   - `generateInvoice`: Uses `createNewRecord` to insert new invoices into the tracked cache and triggers immediate persistence.
   - `completePayment` & `confirmPayment`: Marks records as `MODIFIED` in the `TrackedRecord` state before saving changes.

5. Updated data access patterns across `PaymentManagementService` to use `.data` pointers from `TrackedRecord` objects returned by the datastore, replacing direct pointer access to mapped objects.

6. Added necessary header dependencies including `DataStoreLockGuard.h`, `Invoice.h`, and `SerializedRecords.h` to support locking mechanisms and structured serialization.

</Changes>

<Test>

N/A

</Test>

<Review>

Sreeja Reghukumar, please review

</Review>

Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/datastores/DataStore.cpp

@@ -12,6 +12,7 @@ Date: 19-May-2026
 #include "Config.h"
 #include "SerializedRecords.h"
 #include "FileHelper.h"
+#include "Invoice.h"
 
 /*
 Function: DataStore
@@ -319,6 +320,45 @@ Returns:
 */
 util::Map<std::string, TrackedRecord<Invoice>>& DataStore::getInvoices()
 {
+    auto& serviceBookings = getServiceBookings();
+    auto& inventoryItems = getInventoryItems();
+    util::Map<std::string, TrackedRecord<Invoice>> invoices = loadRecords<Invoice, SerializedInvoice>(m_invoices);
+    refreshCache(m_invoiceCache, invoices);
+    for (int iterator = 0; iterator < m_invoiceCache.getSize(); iterator++)
+    {
+        auto& trackedInvoice = m_invoiceCache.getValueAt(iterator);
+        Invoice* invoice = trackedInvoice.data;
+        if (!invoice)
+        {
+            continue;
+        }
+        const std::string& currentBookingId = invoice->getBookingId();
+        int currentBookingIndex = serviceBookings.find(currentBookingId);
+        if (currentBookingIndex == -1)
+        {
+            throw std::runtime_error("Invalid Service Booking Index.");
+        }
+        ServiceBooking* currentBooking = serviceBookings.getValueAt(currentBookingIndex).data;
+        auto& currentInventoryItemIds = invoice->getPartIDs();
+        util::Map<std::string, InventoryItem*> currentInventoryItems;
+        for (int iterator = 0; iterator < currentInventoryItemIds.getSize(); iterator++)
+        {
+            const std::string& currentItemId = currentInventoryItemIds[iterator];
+            int currentItemIndex = inventoryItems.find(currentItemId);
+            if (currentItemIndex == -1)
+            {
+                throw std::runtime_error("Invalid Inventory item id.");
+            }
+            InventoryItem* currentItem = inventoryItems.getValueAt(currentItemIndex).data;
+            if (!currentItem)
+            {
+                continue;
+            }
+            currentInventoryItems[currentItemId] = currentItem;
+        }
+        invoice->setBooking(currentBooking);
+        invoice->setParts(currentInventoryItems);
+    }
     return m_invoiceCache;
 }
 
@@ -455,6 +495,7 @@ Returns:
 */
 void DataStore::saveInvoices()
 {
+    saveRecords<Invoice, SerializedInvoice>(m_invoices, m_invoiceCache);
 }
 
 /*