text: Title: parametrize_with_cases: map case variables by name rather than position (dict vs list)
  Body: Is it possible to use `parametrize_with_cases` so that the parameters of decorated function are mapped from a dictionary of case data, rather than a list of case data? I'm using the `cases` parameter to generate the case data.
  
  Below is an example that doesn't work (but wish it did):
  
  ```python
  import pytest_cases
  
  def _get_cases():
      '''
      Return a list of test cases to ensure that the addition operator works as expected
      '''
      return [
  
          # test case 1
          {
              "value1": 1,
              "value2": 2,
              "expected": 3,
          },
  
          # test case 2
          {
              "value1": 10,
              "value2": 20,
              "expected": 30,
          },
      ]
  
  
  @pytest_cases.parametrize(case=_get_cases())
  def get_cases(case):
      return case
  
  
  @pytest_cases.parametrize_with_cases('value1, value2, expected', cases=get_cases)
  def test_addition(value1, value2, expected):
      assert value1 + value2 == expected
  ```
  Resulting errors...
  ```
  FAILED debug_pytest_cases.py::test_addition[get_cases-case={'value1': 1, 'value2': 2, 'expected': 3}] - Exception: Unable to unpack parameter value to a tuple: dict_values([1, 2, 3])
  FAILED debug_pytest_cases.py::test_addition[get_cases-case={'value1': 10, 'value2': 20, 'expected': 30}] - Exception: Unable to unpack parameter value to a tuple: dict_values([10, 20, 30])
  ```
  
  This can be "fixed", by having each case be a list (rather than a dict)....
  ```python
  @pytest_cases.parametrize(case=_get_cases())
  def get_cases(case):
      return case.values()  # return the case as list of values only, e.g. [1,2,3]
  ```
  ... but obviously we lose the name mapping, resulting in the case variables getting improperly mapped into the test function...
  ```
  ========================================= FAILURES =========================================
  __________ test_addition[get_cases-case={'expected': 3, 'value2': 2, 'value1': 1}]  __________
  
  value1 = 3, value2 = 2, expected = 1
  
      @pytest_cases.parametrize_with_cases('value1, value2, expected', cases=get_cases)
      def test_addition(value1, value2, expected):
  >       assert value1 + value2 == expected
  E       assert (3 + 2) == 1
  ```
  
  
  So instead of simply converting the case data into a list of values ( via `case.values()`), we could convert it to a list of tuples via `case.items()` , e.g.  `[("expected": 3), ("value1": 1), ("value2": 2)]`
  
  But now we need to unpack these values in our test function...
  ```python
  @pytest_cases.parametrize_with_cases('case_data', cases=get_cases)
  def test_addition(case_data):
  
      # convert case_data back into it's original dictionary form
      case_data = dict(case_data)
  
      # unpack variables from dict. brittle and ugly :(
      value1, value2, expected = [case_data[k] for k in ['value1', 'value2', 'expected']]
  
      assert value1 + value2 == expected
  ```
  This certainly works (I've been using it for a couple years), but it has a few drawbacks: 
  - Every test function will always need this same boiler plate code (unpacking the case data into discrete variables)
  - The unpacking logic is brittle. It requires parameters on both side of `=` to mirror one another (including their order). 
  
  In conclusion, I think it could be notably simpler/convenient to map case data (a dictionary of values) directly to the function parameters (by name) so that no unpacking is necessary (as shown in the top/original example).
  
  I realize that there's certainly some caveats with this approach (e.g. parameter name clashes, illegal parameter names, etc), but I imagine this wouldn't be the first time such issues/compromises needed to be considered.
  
  ... OR  perhaps this functionality already exists  and I just need to RTFM :)
  
  Thank you!