text: Title: Should `pa.check_types` always do schema validation?
  Body: #### Question about pandera
  
  The behavior of `pa.check_types` is a little counter-intuitive because of this check:
  
  ```
                  if (
                      arg_value.pandera.schema is None
                      # don't re-validate a dataframe that contains the same exact
                      # schema
                      or arg_value.pandera.schema != schema # <<<<<<< not sure about this
                  ):
                      try:
                          arg_value = schema.validate(
                              arg_value,
                              head,
                              tail,
                              sample,
                              random_state,
                              lazy,
                              inplace,
                          )
  ```
  https://github.com/unionai-oss/pandera/blob/57d826956b88f89c18e794c728b7f5547ab4ecf8/pandera/decorators.py#L652
  
  This allows errors like:
  
  ```python
  def test_check_types_example_case():
      class Schema(pa.DataFrameModel):
          bid: pa.Int64
          ask: pa.Int64
  
      @pa.check_types
      def calc_spread(df: DataFrame[Schema]) -> DataFrame[Schema]:
          df["spread"] = df["ask"] - df["bid"]
          return df
  
      n = 42
      rng = np.random.default_rng()
      bids = rng.integers(0, 100, size=n, dtype=np.int64)
  
      # This will call Schema.validate():
      df = DataFrame[Schema](data={
          "bid": bids,
          "ask": bids + rng.integers(0, 500, size=n, dtype=np.int64),
      })
      # everything is as it should be...
      print(df.dtypes)
  
      # oops! schema silently violated
      df["ask"] = df["ask"].astype(np.float64)  # oops!
  
      # scheme validation now fails:
      with pytest.raises(pa.errors.SchemaError):
          Schema.validate(df)
      print(df.dtypes)
  
      # I was expecting pa.check_types to catch the schema error
      df = calc_spread(df)
      print(df.dtypes)
  ```
  
  I can resolve this by adding:
  ```
  @pa.check_input(Schema.to_schema()) # check_output would also catch it in this case
  @pa.check_types
  def calc_spread(df: DataFrame[Schema]) -> DataFrame[Schema]:
      # ...
  ```
  
  Is this behavior intended? Or maybe the cached `arg_value.pandera.schema` should be getting invalidated when a column changes?