Support where-clause evaluation in registration annotations

[jeremiah-corrado]

Add (primitive) support for where-clause evaluation to registerCommand and instantiateAndRegister. Both annotations now evaluate the procedure's where-clause and will only generate instantiations for sets of generic parameters where the where-clause would evaluate to true.

The primary goal of this change is to be able to remove extraneous overloads of command procedures that simply return an error message indicating that some set of types and/or array ranks are not supported for that command. For example, in the following code snippet, the second overload of asdf can now be removed because the build system won't attempt to generate an instantiation for it:

@arkouda.registerCommand
proc asdf(x: [?d] ?t): [d] t throws
  where t != bigint
{
  // ...
}

proc asdf(x: [?d] ?t): [d] t throws
  where t == bigint
    do throw new Error("'asdf' does not support 'bigint'");

This feature is not totally general-purpose yet. Current limitations:

• only some param-function calls are currently supported. Specifically, support forisIntegralType and other related procedures from Chapel's Types module is hard-coded in, but any other function calls within a where-clause will not work
• references to queried array types and queried domains are supported; however:
  • only the rank of a queried domain can be referenced (as in the code example below), none of the domain's other param or type methods/fields are accessible
  • referencing an array's etype or rank directly is not yet supported (ex: where x.etype != bool && x.rank < 3)
• referencing param or type fields of a non-array argument is not yet supported (ex: where mySparseSym.matLayout == Layout.CSR)

Eventually, registerCommands.py should be modified to use the Compiler's resolver to speculatively evaluate where-clauses in a much more robust manner. This would in principle remove the above limitations, but is likely a more significant development effort than the solution in this PR.

Limitations aside, this PR allows most of the extraneous procedures currently in Arkouda to be removed.

Note: one can opt out of this feature by setting the ignoreWhereClause argument in the annotation call. This could be useful in an example like the one below, or to get around one of the limitations listed above.

@arkouda.registerCommand(ignoreWhereClause=true)
proc jkl(x: [?d] ?t): [d] t throws
  where d.rank == 1 {
    // special 1D implementation ... 
}

proc jkl(x: [?d] ?t): [d] t throws
  where d.rank > 1 {
    // general ND implementation ... 
}

[ajpotts]

Thanks! Look forward to using this!