text: Title: [ENH] Proposing a "jitter" function
  Body: # Brief Description
  
  Had to use this at work recently, where I had to jitter the data that we had to slightly anonymize it.
  
  All that we did here was to add Gaussian noise scaled by a fraction of the magnitude of each  value.
  
  # Example API
  
  This could operate at two levels: at the pandas Series and DataFrame levels. I implemented the "Series" version at work, but not the "DataFrame" one.
  
  As a Series method, we would do something like this:
  
  ```python
  from typing import Optional, Tuple
  
  def jitter(s: pd.Series, scale_magnitude: np.number, clip: Optional[Tuple[float, float]] = None):
      """
      Jitter a pandas Series by applying Gaussian noise.
      
      By default, the jitter function takes the numeric value of each series element as the mean,
      and uses a multiplier of the numeric value (scale_magnitude) as the standard deviation.
      """
      loc = 0
      scale = s * scale_magnitude
      noise = np.random.normal(loc=0, scale=scale)
      result = s + noise
      if clip:
          result = np.clip(result, *clip)
          
      return result
  ```
  
  I think it might be possible to do the analogous thing for DataFrames.
  
  The API would look like the following:
  
  ```python
  # series  API
  s = df['column_name']
  s.jitter()
  
  # dataframe API
  df = pd.DataFrame(...).jitter("column_name", scale_magnitude=0.1, clip=(0, None))
  ```
  
  What do others think?
  