The issue occurs when a computed field depends on a many2many field with a corresponding inverse field on its comodel.  Consider two models like
```py
class User(models.Model):
    _name = _description = 'test_new_api.user'

    group_ids = fields.Many2many('test_new_api.group')
    group_count = fields.Integer(compute='_compute_group_count', store=True)

    @api.depends('group_ids')
    def _compute_group_count(self):
        for user in self:
            user.group_count = len(user.group_ids)

class Group(models.Model):
    _name = _description = 'test_new_api.group'

    user_ids = fields.Many2many('test_new_api.user')
```
When a user is added to a group with
```py
    group.write({'user_ids': [Command.link(user.id)]})
```
we expect the field `group_count` to be recomputed on `user` only, but it is actually triggered on *all* the records in `group.user_ids`.  This is a real performance issue when there are many records in the relation.

The explanation comes from the fact that
* the framework considers the field `user_ids` is modified on `group`;
* the field `group_count` implicitly depends on `group_ids.user_ids`, which makes it triggered on the users `u` such that `u.group_ids` intersects `group`.

The solution consists in handling the dependencies on inverse many2many field in the field itself.  The field no longer adds the implicit dependency on its inverse field in the trigger tree, but instead determines which records in the comodel are actually impacted by the relation change in the method field.write().