Implement a simplified limit-order matching engine for a stock exchange. You are given a stream of orders in arrival order. Each order is a 5-tuple: (order_id, side, price, quantity, timestamp) Rules: 1. A BUY order can match resting SELL orders with sell_price <= buy_price. 2. A SELL order can match resting BUY orders with buy_price >= sell_price. 3. Match against the best resting price first. - BUY incoming order matches the lowest ask first. - SELL incoming order matches the highest bid first. 4. If multiple resting orders have the same price, match the earliest resting order first. 5. Trade quantity is the minimum of the incoming remaining quantity and the resting remaining quantity. 6. Partially filled orders keep their remaining quantity. Fully filled orders leave the book. 7. Any unfilled remainder of the incoming order is added to the book. 8. The execution price of each trade is the resting order's price. Instead of writing a class, implement a function `solution(orders)` that simulates repeated `add_order(order)` calls from left to right. Return a tuple: - trades: a list of trades in the exact order they occur. Each trade is (buy_order_id, sell_order_id, execution_price, executed_quantity) - buy_book: the remaining BUY orders, sorted by descending price, then ascending timestamp. Each entry is (order_id, price, remaining_quantity, timestamp) - sell_book: the remaining SELL orders, sorted by ascending price, then ascending timestamp. Each entry is (order_id, price, remaining_quantity, timestamp) Do not aggregate orders at the same price; keep individual resting orders.