Speed up of cross_section 💨 (#245)

This speeds up calls to `cross_section` by a factor of 3 😮 

There is some slow down of the cross section calculation described in
#244 .

This reduces the number of internal calls of `cross_section` due to
`_temporary_kinematics` context manager.

Before PR:
```python
In [2]: from chromo.kinematics import FixedTarget
   ...: from chromo.models import Sibyll23e

In [3]: kin_init = FixedTarget(100, 2212, 'O16')
   ...: kin = FixedTarget(80, 2212, 'O16')
   ...:
   ...:
   ...: sib = Sibyll23e(kin_init)

In [4]: def cs(mod, kin):
   ...:     return mod.cross_section(kin).prod
   ...:
In [5]: %timeit cs(sib, kin)
992 μs ± 252 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
```
With this PR:
```python
In [8]: %timeit cs(sib, kin)
328 μs ± 791 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
```

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: StFroese

src/chromo/common.py

@@ -810,7 +810,7 @@ def cross_section(self, kin=None, max_info=False):
                     kin3.p2 = component
                     # this calls cross_section recursively, which is fine
                     cross_section._mul_radd(
-                        fraction, self._cross_section(kin3, max_info=max_info)
+                        fraction, self.cross_section(kin3, max_info=max_info)
                     )
                 return cross_section
             return self._cross_section(kin, max_info=max_info)
@@ -1010,6 +1010,10 @@ def _temporary_kinematics(self, kin):
             yield
         else:
             prev = copy.copy(self.kinematics)
-            self.kinematics = kin
+            self._check_kinematics(kin)
+            self._kinematics = kin
+            self._set_kinematics(kin)
             yield
-            self.kinematics = prev
+            # _check_kinematics not necessary because it's the old kinematics
+            self._kinematics = prev
+            self._set_kinematics(prev)