Add MyFunctionDecl to FunctionScopeInfo to track the function decl.

Additionally add some debugging info - and some comments about how to design solution.
Make CXXCheckConditionalOperands turn on/off diagnostics using SFINAETrap and an additional Complain parameter.
Teach Sema::DeduceReturnType - to deduce the return type from a collection of return statements.

Processing of ActOnFullExpression is incorrect - we need to steal the expression evaluation context - and then push and pop it off the expression evaluation stack - but before that - we need to add ExprCleanupObjects to the ExpressionEvaluationContext
Cache away the EvaluationExpressionContext within function-scope-info
so that it pushed on and used during return type deduction.
  - essentially for C++ and ObjC, it retains the potentially odr-usable expressions.
Make sure non-capturing functions can also save their expression state.

Additionally add some comments why we don't need to save potential-capture state for generic lambdas since they are only created within a dependent context - and the return-expression finidh-full-expression - is always acted upon then.
An initial attempt at finding the common type.

Iterate through each return stmt and try and merge it against the others.

If we can not merge it to a common type, or can have a different common-type based on the order of merging - then diagnose it.
Do a rudimentary form of return-type deduction

Fix the tests to work with this since now char and int return types can be merged.
Add a different version of calculating the unique common type
  - iterate through each return stmt
    - find the set of all its common expressions and types when unified against every other return stmt
    - within that set, find the common type, given all the commontypes and modified-exprs for this return stmt
  - use that unified-common-type for the return stmt to now find the common type against every other return stmt - and we should not discover any new common types - if so, an error should occur.

Repeat this for every other Return stmt.

Yuk - this is big-Oh of N2 - and can probably be optimized.

Additionally, to handle nullptrs within return stmts when they are unified with other ptrs, make sure an explicit c-cast is added to the implicit cast - so that the type of that cast can not be subverted or modified (such as they can be for nullptrs that are implicitly cast and only remember the implicit cast, in the context of return type deduction, when we deduce other common types from them)
Add disable diagnostics argument - and make lvalue-to-rvalue unification work
Make recursion work.

Check if the function type has been deduced, while processing the current functions return statement, and if so, check if the common type with the previous-return-statement and the current return stmt is the same, and if it is, allow it, else emit an error!
Make sure return stmts get added to the return stack, even after a recursive deduction.

Not sure if this affects anything just yet - but seems like a good idea to track all the return stmts regardless of whether deduction has occured or not.
Implement recursion if recursive call is within the first return stmt of a conditional.

For e.g.
auto f(int n) {
  return n > 10 ? 5 : foo(++n);
}

This is done by keeping a track of when we are either parsing or transforming a return stmt, if we encounter a conditional, track its middle expression - and clear it out once we are done processing its end expression - and when doing return type deduction - if there are no other returns (actually we should only be tracking the conditional, if no returns on the return stms stack exists - perhaps will fix this in the next commit) to do the deduction from then use any tracked middle expressions to deduce from.

One essentially has to have seen at least one middle expression before deducing the recursive return type.