On large recordsets I got some severe performance issues while browsing through an inherits relation.
For example I have a batch process exporting a csv file with products variants:

I have to export 50.000 products.

If I do :
`variant.categ_id` It takes a very long time to get the result.

If I do:
`variant.product_tmpl_id.categ_id` The result is immediate

The problem is that the global perfomance of the application is impacted by this problem.

For example my POS takes more than 15 minutes to load. Because I have 26.000 products and the compute price method uses a lot browsing through the inherits such like `product.cated_id`, `product.uom_id` and they all takes a huge time to compute.

Same issue in this case.

If I do :
`variant.price` It takes a very long time to get the result.

If I do:
`variant.product_tmpl_id.price` The result is immediate

Could you help me ?


Simple way to reproduce:

1/ Create a new database and install sale module
2/ Launch following script through odoo shell :

```python
# -*- coding: utf-8 -*-
import logging

_logger = logging.getLogger(__name__)
self = self  # noqa

nb_product = 50000

i = 0
while i < nb_product:
    prod = self.env['product.template'].create({'name': 'product_%s' % i})
    i += 1
    if i % 1000 == 0:
        self.env.cr.commit()
        _logger.info("%s Products Created" % i)
```

2/ Launch following script through odoo shell :
```python
# -*- coding: utf-8 -*-
import logging

_logger = logging.getLogger(__name__)
self = self  # noqa


products = self.env['product.product'].search([])

for product in products:
    # Immediate response
    _logger.info('Category Template %s' % product.product_tmpl_id.categ_id)
    # Lagging response
    _logger.info('Category Variant %s' % product.categ_id) 
    break
```
lines.write({inverse: False})
class Many2many(_RelationalMulti):
    """ Many2many field; the value of such a field is the recordset.
        :param comodel_name: name of the target model (string)
        The attribute ``comodel_name`` is mandatory except in the case of related
        fields or field extensions.
        :param relation: optional name of the table that stores the relation in
            the database (string)
        :param column1: optional name of the column referring to "these" records
            in the table ``relation`` (string)
        :param column2: optional name of the column referring to "those" records
            in the table ``relation`` (string)
        The attributes ``relation``, ``column1`` and ``column2`` are optional. If not
        given, names are automatically generated from model names, provided
        ``model_name`` and ``comodel_name`` are different!
        :param domain: an optional domain to set on candidate values on the
            client side (domain or string)
        :param context: an optional context to use on the client side when
            handling that field (dictionary)
        :param limit: optional limit to use upon read (integer)
    """
    type = 'many2many'
    _slots = {
        'relation': None,               
        'column1': None,                
        'column2': None,                
        'auto_join': False,             
        'limit': None,                  
    }
    def __init__(self, comodel_name=Default, relation=Default, column1=Default,