Should signature verification work using two different RSA libraries?
Yes, RSA signature generation and verification should work identically on different libraries. PKCS#1 - the dominant standard for signature generation and verification - has a complete and formal description of how the configuration / input is transformed into the output.

This includes:


the key specifications (and possible encoding);
the hashing;
the padding and hash indicators;
the modular exponentiation;
the transformation into octets of the result.


There are test vectors available from NIST as well, so it is possible to (partially) verify the correctness of an implementation against well known test vectors.



That doesn't mean that there may not be differences in implementation between libraries, so some libraries:


require a key in a specific format (and error handling if the format is incorrect is not always up to par);
require CRT (Chinese Remainder Theorem) parameters for a key;
require a pre-calculated hash value, some libraries an initialized hash function and some libraries just need an indication of the hash function (and some just assume a specific hash function, often SHA-1);
offer implicit character encoding for when the input is a text string (this may also be implicit for the programming language / runtime);
allow for online calculation of the hash / signature by offering update / final functionality  or streaming;
implicitly or explicitly perform the choice of the padding mode (PKCS#1, PSS, ISO 9797, RAW, etc.);
offer to encode or even implicitly encode the result into a text string.


Less common, but still possible is the way bytes are ordered for lower level functions. You may also have to configure implementation specific parameters, such as a random number generator for protecting the implementation or performing PSS signature generation. PSS may also require parameters - a second hash function for instance - for Mask Generation Function (MGF-1).

These are all design choices that may influence the outcome of the signature generation or verification. So a developer still needs to study the API to known what to expect, despite the well written PKCS#1 standard.



Fortunately, once the algorithm works it is unlikely to fail unless you manage to bugger up the character encoding of the message or the encoding / decoding of the signature.



It seems you got stuck on (3). Double calculation of the hash is a common mistake. Note that PKCS#1 signature describes the signing of messages and includes the hashing within the signature generation description, so having the signature also generate the hash is common among cryptographic APIs.