Add TimSort implementation and UI entries

Introduce TimSort support across the app: add TIM_SORT_WIKI to UrlConstants, implement timSort (with insertionSortRange and mergeRanges) in SortingService to produce SortSnapshot sequences (uses RUN=32, sorts runs then merges, marks comparing/unsorted/sorted states), and wire the algorithm into SortingComponent (UI entry and case branch). Also add TIMSORT_EXPLANATION translations in de.json and en.json, and add a few UI label keys (STIFFNESS, ELONGATION, RESTART_SIMULATION) to both locale files.

src/assets/i18n/en.json

@@ -371,6 +371,7 @@
       "BUBBLE_SORT_EXPLANATION": "repeatedly compares adjacent elements and swaps them if they are in the wrong order. The largest element \"bubbles\" to the end of the list like an air bubble. Advantage: Extremely simple to understand and implement; detects already sorted lists very quickly. Disadvantage: Very inefficient for large lists (runtime O(n²)). Rarely used in practice.",
       "QUICK_SORT_EXPLANATION": "follows the \"divide and conquer\" principle. A \"pivot\" element is selected, and the array is divided into two halves: elements smaller than the pivot and elements larger than the pivot. Advantage: On average one of the fastest sorting algorithms (O(n log n)); requires no additional memory (in-place). Disadvantage: Slow in the worst case (O(n²)) if the pivot is chosen poorly. Is not stable (changes order of equal elements).",
       "HEAP_SORT_EXPLANATION": "organizes the data initially into a special tree structure (Binary Heap). The largest element (the root) is extracted and sorted to the end, then the tree is repaired. Advantage: Guarantees a fast runtime of O(n log n), even in the worst case. Requires almost no additional memory. Disadvantage: Often slightly slower than Quick Sort in practice because the jumps in memory (heap structure) utilize the CPU cache less effectively.",
+      "TIMSORT_EXPLANATION": "is a hybrid sorting algorithm derived from Merge Sort and Insertion Sort. It divides the array into small 'runs' and sorts each using Insertion Sort, then merges them step by step using Merge Sort. Advantage: Extremely efficient on real-world data that is often partially sorted — O(n log n) in the worst case and O(n) in the best case. It is the standard sorting algorithm in Python and Java. Disadvantage: More complex to implement than a pure algorithm and requires additional memory for the merge step.",
       "DISCLAIMER": "The choice of the \"best\" sorting algorithm depends heavily on the data and the constraints. In computer science, three scenarios are often considered:",
       "DISCLAIMER_1": "Best Case: The data is already nearly sorted (Bubble Sort shines here, for example).",
       "DISCLAIMER_2": "Average Case: The statistical norm.",
@@ -482,6 +483,9 @@
     "WIND_OFF": "Wind Off",
     "OUTLINE_ON": "Show Mesh",
     "OUTLINE_OFF": "Hide Mesh",
+    "STIFFNESS": "Stiffness",
+    "ELONGATION": "Elongation",
+    "RESTART_SIMULATION": "Restart Simulation",
     "EXPLANATION": {
       "TITLE": "Real-time Cloth Simulation on the GPU",
       "CLOTH_SIMULATION_EXPLANATION_TITLE": "Cloth Simulation",