ENH: Allow pd.Series to fill NA with a callable
#### Is your feature request related to a problem?

I wanted to do Series additions/subtractions where two Series objects' index may not align. I was using the [`pd.Series.add()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.add.html) function, which first aligns two Series' by their indices, and then do the adding at each index -- this is great. However, when dealing with NaNs generated at misaligned indices, I want to use a callable (e.g. a function or a class constructor) with a Series item's index and/or value as arguments to fill the NaNs. Right now Pandas.Series doesn't support such functionality, the `fill_value` argument for the  `pd.Series.add()` function can be a float number at best.

Example:
```python
idx1 = [1,2,3]
idx2 = [2,3,4]
s1 = pd.Series((_**2 for _ in idx1), index=idx1, name='square')
s2 = pd.Series((_**2 for _ in idx2), index=idx2, name='square')
```
Hopefully with
```python
result = s1.add(s2, fill_value=lambda idx, val: idx**2)
```
the holes introduced when aligning `s1` and `s2` can be filled by calling the `lambda` function on the NA items in the Series, so eventually the `result` is effectively `pd.Series([1,4,9,16]) + pd.Series([1,4,9,16])`, and looks like 
```python
result
>>>
1     2
2     8
3    18
4    32
```

#### Describe the solution you'd like

Whenever a Series needs to fill NAs, e.g. `pd.Series.fillna()`, `pd.Series.align()`, `pd.Series.add()` etc, the `fill_value` argument should be able to accept a callable that takes two arguments `idx` and `val`, and call it with the Series' (index, value) pair as arguments to fill NAs.

#### API breaking implications

This may break the API behavior in (imo a rare) case a user intentionally wants to put callable objects in a Series to fill NAs. For example:
```python
s = pd.Series([min, max, sum, np.nan])
result = s.fillna(max)
```
Current behavior
```python
result
>>>
0    <built-in function min>
1    <built-in function max>
2    <built-in function sum>
3    <built-in function max>
```

New behavior after the proposed change:
```python
result
>>>
0    <built-in function min>
1    <built-in function max>
2    <built-in function sum>
3                          3
```
because at item 3, calling `max(3, np.nan)` results in `3`.

#### Describe alternatives you've considered

A workaround for `pd.Series.fillna()` but can use a callable to generate fill values is to create a `backup` Series separately with that callable, and use `pd.Series.mask()` instead. Suppose `func = lambda idx, val: idx**2`
```python
backup = pd.Series((func(idx, val) for idx, val in s.items()), index=s.index)
result = s.mask(pd.isna, other=backup)
result
>>>
0    <built-in function min>
1    <built-in function max>
2    <built-in function sum>
3                          9
```
Above is just for the `pd.Series.fillna()` function, and `.add()` and `.align()` functions can use similar approaches, but obviously it gets quite tedious.