`Explain <query>` should not fail if meeting errors when optimizing the query

[HaoYang670]

Is your feature request related to a problem or challenge? Please describe what you are trying to do.
Currently, the explain <query> gives the same error messages as the query if it meets errors in plan optimizations.
For example, the query in #4677 meets an internal error when initializing the physical plan:

❯ select count(*) from (select * from t union all select * from t);
Internal("create_physical_expr expected same number of fields, got got Arrow schema with 1  and DataFusion schema with 0")

But, we evenly can't see the logical plan of it, although there is no error met in the logical optimization

❯ explain select count(*) from (select * from t union all select * from t);
Internal("create_physical_expr expected same number of fields, got got Arrow schema with 1  and DataFusion schema with 0")
❯ explain verbose select count(*) from (select * from t union all select * from t);
Internal("create_physical_expr expected same number of fields, got got Arrow schema with 1  and DataFusion schema with 0")

Describe the solution you'd like
The explain should print the plans until meeting errors. This could help developers to debug.
For the above example, I'd like the explain and explain verbose to print like this:

❯ explain select count(*) from (select * from t union all select * from t);
+---------------+-------------------------------------------------------------+
| plan_type     | plan                                                        |
+---------------+-------------------------------------------------------------+
| logical_plan  | Projection: COUNT(UInt8(1))                                 |
|               |   Aggregate: groupBy=[[]], aggr=[[COUNT(UInt8(1))]]         |
|               |     Union                                                   |
|               |       TableScan: t projection=[a]                           |
|               |       TableScan: t projection=[a]                           |
| physical_plan | InternalError("...")                                        |
|               |                                                             |
+---------------+-------------------------------------------------------------+

❯ explain verbose select count(*) from (select * from t union all select * from t);
+------------------------------------------------------------+-----------------------------------------------------------------+
| plan_type                                                  | plan                                                            |
+------------------------------------------------------------+-----------------------------------------------------------------+
| initial_logical_plan                                       | Projection: COUNT(UInt8(1))                                     |
|                                                            |   Aggregate: groupBy=[[]], aggr=[[COUNT(UInt8(1))]]             |
|                                                            |     Union                                                       |
|                                                            |       Projection: t.a, t.b                                      |
|                                                            |         TableScan: t                                            |
|                                                            |       Projection: t.a, t.b                                      |
|                                                            |         TableScan: t                                            |
| logical_plan after inline_table_scan                       | SAME TEXT AS ABOVE                                              |
| logical_plan after type_coercion                           | SAME TEXT AS ABOVE                                              |
| logical_plan after extract_equijoin_predicate              | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after unwrap_cast_in_comparison               | SAME TEXT AS ABOVE                                              |
| logical_plan after decorrelate_where_exists                | SAME TEXT AS ABOVE                                              |
| logical_plan after decorrelate_where_in                    | SAME TEXT AS ABOVE                                              |
| logical_plan after scalar_subquery_to_join                 | SAME TEXT AS ABOVE                                              |
| logical_plan after subquery_filter_to_join                 | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_filter                        | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_cross_join                    | SAME TEXT AS ABOVE                                              |
| logical_plan after common_sub_expression_eliminate         | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_limit                         | SAME TEXT AS ABOVE                                              |
| logical_plan after propagate_empty_relation                | SAME TEXT AS ABOVE                                              |
| logical_plan after rewrite_disjunctive_predicate           | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_outer_join                    | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_limit                         | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_filter                        | SAME TEXT AS ABOVE                                              |
| logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after unwrap_cast_in_comparison               | SAME TEXT AS ABOVE                                              |
| logical_plan after common_sub_expression_eliminate         | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_projection                    | Projection: COUNT(UInt8(1))                                     |
|                                                            |   Aggregate: groupBy=[[]], aggr=[[COUNT(UInt8(1))]]             |
|                                                            |     Union                                                       |
|                                                            |       TableScan: t projection=[a]                               |
|                                                            |       TableScan: t projection=[a]                               |
| logical_plan after inline_table_scan                       | SAME TEXT AS ABOVE                                              |
| logical_plan after type_coercion                           | SAME TEXT AS ABOVE                                              |
| logical_plan after extract_equijoin_predicate              | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after unwrap_cast_in_comparison               | SAME TEXT AS ABOVE                                              |
| logical_plan after decorrelate_where_exists                | SAME TEXT AS ABOVE                                              |
| logical_plan after decorrelate_where_in                    | SAME TEXT AS ABOVE                                              |
| logical_plan after scalar_subquery_to_join                 | SAME TEXT AS ABOVE                                              |
| logical_plan after subquery_filter_to_join                 | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_filter                        | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_cross_join                    | SAME TEXT AS ABOVE                                              |
| logical_plan after common_sub_expression_eliminate         | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_limit                         | SAME TEXT AS ABOVE                                              |
| logical_plan after propagate_empty_relation                | SAME TEXT AS ABOVE                                              |
| logical_plan after rewrite_disjunctive_predicate           | SAME TEXT AS ABOVE                                              |
| logical_plan after eliminate_outer_join                    | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_limit                         | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_filter                        | SAME TEXT AS ABOVE                                              |
| logical_plan after single_distinct_aggregation_to_group_by | SAME TEXT AS ABOVE                                              |
| logical_plan after simplify_expressions                    | SAME TEXT AS ABOVE                                              |
| logical_plan after unwrap_cast_in_comparison               | SAME TEXT AS ABOVE                                              |
| logical_plan after common_sub_expression_eliminate         | SAME TEXT AS ABOVE                                              |
| logical_plan after push_down_projection                    | SAME TEXT AS ABOVE                                              |
| logical_plan                                               | Projection: COUNT(UInt8(1))                                     |
|                                                            |   Aggregate: groupBy=[[]], aggr=[[COUNT(UInt8(1))]]             |
|                                                            |     Union                                                       |
|                                                            |       TableScan: t projection=[a]                               |
|                                                            |       TableScan: t projection=[a]                               |
| initial_physical_plan                                      | InernalError("...")                                             |
|                                                            |                                                                 |
+------------------------------------------------------------+-----------------------------------------------------------------+

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

[Jefffrey]

I've got an initial working version for physical planner errors: #4819

Gist is handling the results error cases to ensure these are appended to the stringified plans, instead of simply returning early, which required some modifications to the observer pattern, since need observer to not only run for successes, but errors as well to capture these:

https://github.com/apache/arrow-datafusion/blob/cdd21be7a1c987958e0a9dff5c498080c6277e66/datafusion/core/src/physical_plan/planner.rs#L1744-L1749

Alternative would be for optimize_internal() to return which plan_type failed as part of the error, if don't want to modify the observer in this way.

But if want to do for logical plan too (if it makes sense to?), this seems to become much tricker. Could attempt something similar as I did for physical, applying here:

https://github.com/apache/arrow-datafusion/blob/5b70e3543f5c10832e43ed25e7d4166cf0c1df78/datafusion/core/src/execution/context.rs#L1650-L1658

But the observer pattern would require extensive changes too it seems, to account for calling it for error cases too (this might be too big a change?). Could attempt to go with alternative described above, where error returns the plan type.

Any thoughts on the logical plan part @HaoYang670 ?