Introduce a TimelineItemThreadSummary object (#4032)

* Introduce a `TimelineItemThreadSummary` object to hold details about threads starting from that particular item

This patch introduces a thread summary object that will be available on main timeline messages that are the root for a given thread.
It currently provides the latest message content and sender for that thread but it will grow to provide info on the number of replies, unreads etc.

It also add a new UI component called `TimelineThreadSummaryView` that makes use of this data and is in turn used by the bubbled styler to render it in the timeline.

The rest of the PR is about refactoring on the `RoomTimelineItemFactory` so that replies and thread summaries use similar paths and builders.

* Add a feature flag for threads

* Address PR comments

* Converge on single implementation for message previews

ElementX/Sources/Mocks/Generated/SDKGeneratedMocks.swift

@@ -20353,6 +20353,82 @@ open class TaskHandleSDKMock: MatrixRustSDK.TaskHandle, @unchecked Sendable {
         }
     }
 }
+open class ThreadSummarySDKMock: MatrixRustSDK.ThreadSummary, @unchecked Sendable {
+    init() {
+        super.init(noPointer: .init())
+    }
+
+    public required init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
+        fatalError("init(unsafeFromRawPointer:) has not been implemented")
+    }
+
+    fileprivate var pointer: UnsafeMutableRawPointer!
+
+    //MARK: - latestEvent
+
+    var latestEventUnderlyingCallsCount = 0
+    open var latestEventCallsCount: Int {
+        get {
+            if Thread.isMainThread {
+                return latestEventUnderlyingCallsCount
+            } else {
+                var returnValue: Int? = nil
+                DispatchQueue.main.sync {
+                    returnValue = latestEventUnderlyingCallsCount
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                latestEventUnderlyingCallsCount = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    latestEventUnderlyingCallsCount = newValue
+                }
+            }
+        }
+    }
+    open var latestEventCalled: Bool {
+        return latestEventCallsCount > 0
+    }
+
+    var latestEventUnderlyingReturnValue: ThreadSummaryLatestEventDetails!
+    open var latestEventReturnValue: ThreadSummaryLatestEventDetails! {
+        get {
+            if Thread.isMainThread {
+                return latestEventUnderlyingReturnValue
+            } else {
+                var returnValue: ThreadSummaryLatestEventDetails? = nil
+                DispatchQueue.main.sync {
+                    returnValue = latestEventUnderlyingReturnValue
+                }
+
+                return returnValue!
+            }
+        }
+        set {
+            if Thread.isMainThread {
+                latestEventUnderlyingReturnValue = newValue
+            } else {
+                DispatchQueue.main.sync {
+                    latestEventUnderlyingReturnValue = newValue
+                }
+            }
+        }
+    }
+    open var latestEventClosure: (() -> ThreadSummaryLatestEventDetails)?
+
+    open override func latestEvent() -> ThreadSummaryLatestEventDetails {
+        latestEventCallsCount += 1
+        if let latestEventClosure = latestEventClosure {
+            return latestEventClosure()
+        } else {
+            return latestEventReturnValue
+        }
+    }
+}
 open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable {
     init() {
         super.init(noPointer: .init())

ElementX/Sources/Mocks/SDK/EventTimelineItem.swift

@@ -14,7 +14,11 @@ struct EventTimelineItemSDKMockConfiguration {
     var sender = ""
     var senderProfile: ProfileDetails?
     var isOwn = false
-    var content: TimelineItemContent = .msgLike(content: .init(kind: .redacted, reactions: [], threadRoot: nil, inReplyTo: nil))
+    var content: TimelineItemContent = .msgLike(content: .init(kind: .redacted,
+                                                               reactions: [],
+                                                               inReplyTo: nil,
+                                                               threadRoot: nil,
+                                                               threadSummary: nil))
 }
 
 extension EventTimelineItem {
@@ -44,8 +48,9 @@ extension EventTimelineItem {
                                                                                                isEdited: false,
                                                                                                mentions: nil)),
                                                                  reactions: [],
+                                                                 inReplyTo: nil,
                                                                  threadRoot: nil,
-                                                                 inReplyTo: nil))
+                                                                 threadSummary: nil))
         
         return .init(configuration: .init(content: content))
     }