Fix LangStr hash/eq contract violation with plain str (closes #255)

[trungminhdo4-glitch]

Problem

LangStr.__hash__ returned hash((text, lang)) but __eq__ falls back to
value-only comparison with plain str. This violates Python's
a == b => hash(a) == hash(b) invariant: a LangStr that compares equal to a
plain str has a different hash, making it unfindable in str-keyed dicts/sets.

Closes #255.

Reproduction

from rigour.langs.text import LangStr
a = LangStr("foo", "eng")
a == "foo"                      # True
hash(a) == hash("foo")          # False  -- broken
{"foo": 1}.get(a)               # None   -- not found
{"foo", a}                      # 2 elements instead of 1

Root Cause

In rigour/langs/text.py, __hash__ always encodes the (content, lang)
tuple, but __eq__ ignores lang when the other operand is a plain str.

Change

     def __hash__(self) -> int:
-        return hash((super().__str__(), self.lang))
+        return hash(str(self))

This follows Option 1 from the issue: hash like a plain str, preserving the
documented "transparent string" behavior. Two LangStrs that differ only in
lang share a hash bucket (acceptable - equality still separates them).

Tests

Updated the existing test assertion and added 5 regression tests:

• test_langstr_hash_eq_contract: a == b => hash(a) == hash(b)
• test_langstr_str_keyed_dict: lookup in str-keyed dict works
• test_langstr_str_keyed_set: set deduplication works
• test_langstr_lang_differing: same text, different lang share hash
• test_langstr_none_lang: None lang satisfies contract

All 6 lang tests pass.

Compatibility

• No public API changes
• __hash__ still returns int
• __eq__ unchanged
• Existing behavior preserved for LangStr == LangStr (lang-sensitive)

Risks

Very low. The fix aligns __hash__ with the documented promise that LangStr
"behaves like a regular string." Hash collisions between LangStrs with different
languages are benign.

Out of Scope

• Option 2 (making equality lang-sensitive across the board)
• Any changes to other modules