How to update the "LastModifiedDate" timestamp automatically on parent entity when adding/removing child entities

Is there a way to automatically enforce parent entity to be timestamped as having been modified, if any of its dependent child items are added/deleted/modified? The key word is automatically. I know this can be done by manipulating the DbEntry's EntityState or by manually setting the timestamp field in the parent, but I need this done on a number of parent-child entities in a system, so the desire is to have EF (or a related component) automatically do this somehow.

More Background and Examples

Let's say we have an Order and Order Items (1-many). When order items are added/removed from an order, the parent order itself needs to be updated to store the last modified timestamp.

public interface IModifiableEntity
{
    DateTime LastModifiedOn { get; set; }
}

public class Order : IModifiableEntity
{
    // some Order fields here...

    // timestamp for tracking when the order was changed
    public DateTime LastModifiedOn { get; set; }

    // list of order items in a child collection 
    public ICollection<OrderItem> OrderItems { get; set; }
}

public class OrderItem
{
    public int OrderId { get; set; }
    // other order item fields...
}

Somewhere in application logic:

public void AddOrderItem(OrderItem orderItem)
{
    var order = _myDb.Orders.Single(o => o.Id == orderItem.OrderId);
    order.OrderItems.Add(orderItem);
    _myDb.SaveChanges();
}

I already have a pattern in place to detect modified entities and set timestamps automatically via EF's SaveChanges, like this:

public override int SaveChanges()
{
    var timestamp = DateTime.Now;

    foreach (var modifiableEntity in ChangeTracker.Entries<IModifiableEntity>())
    {
        if (modifiableEntity.State == EntityState.Modified)
        {
            modifiableEntity.Entity.UpdatedOn = timestamp;
        }
    }

    return base.SaveChanges();
}

That works great if any direct fields on an IModifiableEntity are updated. That entity's state will then be marked as Modified by EF, and my custom SaveChanges() above will catch it and set the timestamp field correctly.

The problem is, if you only interact with a child collection property, the parent entity is not marked as modified by EF. I know I can manually force that via context.Entry(myEntity).State or just by manually setting the LastModifiedOn field when adding child items in application logic, but that wouldn't be done centrally, and is easy to forget.

I DO NOT want to do this:

public void AddOrderItem(OrderItem orderItem)
{
    var order = _myDb.Orders.Single(o => o.Id == orderItem.OrderId);
    order.OrderItems.Add(orderItem);

    // this works but is very manual and EF infrastructure specific
    _myDb.Entry(order).State = EntityState.Modified;

    // this also works but is very manual and easy to forget
    order.LastModifiedOn = DateTime.Now;

    _myDb.SaveChanges();
}

Any way I can do this centrally and inform EF that a "root" entity of a parent-child relationship needs to be marked as having been updated?