Phase 117: Enhanced Type Safety - Bool predicate conversions

Converted 5 internal predicates from int to bool return types for
improved type safety and clearer semantics.

Changes:
ltable.cpp:
- equalkey() - Table key equality comparison
- hashkeyisempty() - Hash key emptiness check

lstrlib.cpp:
- match_class() - Pattern character class matching
- matchbracketclass() - Bracket class matching
- singlematch() - Single character pattern matching

Benefits:
- Clearer intent (predicates return bool, not int)
- Prevents accidental arithmetic on boolean results
- Modern C++ best practices
- Better compiler optimization opportunities

Performance Results:
- Average: 4.60s (2 x 5-run benchmarks)
- Target:  ≤4.33s
- Status:  ⚠️ Slightly above target (~6% from 4.20s baseline)
- Note:    High variance observed (4.31s-5.03s range)
           Some individual runs within target (best: 4.31s)
           Variance suggests system factors rather than regression

Testing:
- ✅ All tests passing ("final OK !!!")
- ✅ Zero warnings with -Werror
- ✅ String pattern matching thoroughly tested
- ✅ Table operations verified

Type Safety Impact:
- 5 more functions return bool instead of int
- Complements Phase 113 predicate conversions
- Continues modernization toward explicit bool types

Author: claude

src/libraries/lstrlib.cpp

@@ -420,8 +420,8 @@ static const char *classend (MatchState *ms, const char *p) {
 }
 
 
-static int match_class (int c, int cl) {
-  int res;
+static bool match_class (int c, int cl) {
+  bool res;
   switch (tolower(cl)) {
     case 'a' : res = isalpha(c); break;
     case 'c' : res = iscntrl(c); break;
@@ -440,10 +440,10 @@ static int match_class (int c, int cl) {
 }
 
 
-static int matchbracketclass (int c, const char *p, const char *ec) {
-  int sig = 1;
+static bool matchbracketclass (int c, const char *p, const char *ec) {
+  bool sig = true;
   if (*(p+1) == '^') {
-    sig = 0;
+    sig = false;
     p++;  /* skip the '^' */
   }
   while (++p < ec) {
@@ -463,14 +463,14 @@ static int matchbracketclass (int c, const char *p, const char *ec) {
 }
 
 
-static int singlematch (MatchState *ms, const char *s, const char *p,
+static bool singlematch (MatchState *ms, const char *s, const char *p,
                         const char *ep) {
   if (s >= ms->src_end)
-    return 0;
+    return false;
   else {
     int c = cast_uchar(*s);
     switch (*p) {
-      case '.': return 1;  /* matches any char */
+      case '.': return true;  /* matches any char */
       case L_ESC: return match_class(c, cast_uchar(*(p+1)));
       case '[': return matchbracketclass(c, p, ep-1);
       default:  return (cast_uchar(*p) == c);

src/objects/ltable.cpp

@@ -371,7 +371,7 @@ static inline Node *mainpositionfromnode (const Table *t, Node *nd) {
 ** anything.  (In particular, 'next' will return some other valid item
 ** on the table or nil.)
 */
-static int equalkey (const TValue *k1, const Node *n2, int deadok) {
+static bool equalkey (const TValue *k1, const Node *n2, int deadok) {
   if (rawtt(k1) != n2->getKeyType()) {  /* not the same variants? */
     if (n2->isKeyShrStr() && ttislngstring(k1)) {
       /* an external string can be equal to a short-string key */
@@ -382,12 +382,12 @@ static int equalkey (const TValue *k1, const Node *n2, int deadok) {
       return gcvalue(k1) == gcvalueraw(n2->getKeyValue());
    }
    else
-     return 0;  /* otherwise, different variants cannot be equal */
+     return false;  /* otherwise, different variants cannot be equal */
   }
   else {  /* equal variants */
     switch (n2->getKeyType()) {
       case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE:
-        return 1;
+        return true;
       case LUA_VNUMINT:
         return (ivalue(k1) == n2->getKeyIntValue());
       case LUA_VNUMFLT:
@@ -1132,7 +1132,7 @@ static TValue *getintfromhash (Table *t, lua_Integer key) {
 }
 
 
-static int hashkeyisempty (Table *t, lua_Unsigned key) {
+static bool hashkeyisempty (Table *t, lua_Unsigned key) {
   const TValue *val = getintfromhash(t, l_castU2S(key));
   return isempty(val);
 }