text: Title: Call args/kwargs stored in a Spy can be overwritten without intention
  Body: Suppose I have the following class definition and test code (in `test.py`):
  
  ```
  class AClass:
  
      def foo(self, x):
          return None
  
      def bar(self):
          x = {"data": [1]}
          self.foo(x)
          x["data"].append(2)
          self.foo(x)
  
  def test_bar(mocker):
      a = AClass()
      spy = mocker.spy(a, "foo")
      a.bar()
      print(spy.call_args_list)
  ```
  I want to check if `foo` has been called with the correct arguments. However, when I run `pytest -s test.py` I see the following output:
  ```
  ...
  test.py::test_bar [call({'data': [1, 2]}), call({'data': [1, 2]})]
  ...
  ```
  where I would've expected:
  ```
  ...
  test.py::test_bar [call({'data': [1]}), call({'data': [1, 2]})]
  ...
  ```
  I suspect the spy stores a reference to the calling args and kwargs, which allows for this behavior to happen. Creating a `deepcopy` would solve the issue, but I realize it can be quite costly to do so. Alternatively, having a flag to enable deep-copying if required would be useful.